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

• include
• miopen

miopen.h

Go to the documentation of this file.

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

2  *

3  * MIT License

4  *

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

6  *

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

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

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

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

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

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

13  *

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

15  * copies or substantial portions of the Software.

16  *

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

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

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

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

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

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

23  * SOFTWARE.

24  *

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

26 #ifndef MIOPEN_GUARD_MIOPEN_H_

27 #define MIOPEN_GUARD_MIOPEN_H_

28 

29 #ifdef __clang__

30 #pragma clang diagnostic push

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

32 #endif

33 

34 #include <stddef.h>

35 #include <stdbool.h>

36 #include <miopen/config.h>

37 #include <miopen/export.h>

38 

39 #if MIOPEN_BACKEND_OPENCL

40 #define CL_TARGET_OPENCL_VERSION 120

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

42 #include <OpenCL/cl.h>

43 #else

44 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS

45 #include <CL/cl.h>

46 #endif

47 

48 #elif MIOPEN_BACKEND_HIP

49 #include <hip/hip_runtime_api.h>

50 #endif

51 

52 /*

53  * @defgroup convolutions

54  * @defgroup pooling

55  * @defgroup handle

56  * @defgroup layernorm

57  * @defgroup LRN

58  * @defgroup batchnorm

59  * @defgroup activation

60  * @defgroup tensor

61  * @defgroup softmax

62  * @defgroup RNN

63  * @defgroup fusion

64  * @defgroup LossFunction

65  * @defgroup TensorReduce

66  * @defgroup find2

67  * @defgroup ReduceExtreme

68  * @defgroup groupnorm

69  * @defgroup cat

70  * @defgroup SGD

71  * @defgroup getitem

72  * @defgroup ReduceCalculation

73  * @defgroup RotaryPositionalEmbeddings

74  * @defgroup ReLU

75  *

76  */

77 

79 #define MIOPEN_DECLARE_OBJECT(name) \

80  struct name \

81  { \

82  }; \

83  typedef struct name* name##_t;

84 

85 #ifdef __cplusplus

86 extern "C" {

87 #endif

88 

89 #if MIOPEN_BACKEND_OPENCL

90 typedef cl_command_queue miopenAcceleratorQueue_t;

91 #elif MIOPEN_BACKEND_HIP

92 typedef hipStream_t miopenAcceleratorQueue_t;

93 #endif

94 

98 MIOPEN_DECLARE_OBJECT(miopenHandle);

99 

108 typedef enum

109 {

110  miopenStatusSuccess = 0,

111  miopenStatusNotInitialized = 1,

112  miopenStatusInvalidValue = 2,

113  miopenStatusBadParm = 3,

114  miopenStatusAllocFailed = 4,

115  miopenStatusInternalError = 5,

116  miopenStatusNotImplemented = 6,

117  miopenStatusUnknownError = 7,

118  miopenStatusUnsupportedOp = 8,

119  miopenStatusGpuOperationsSkipped = 9,

120  miopenStatusVersionMismatch = 10,

121 } miopenStatus_t;

122 

123 #ifdef MIOPEN_BETA_API

124 typedef enum

125 {

126  miopenF8RoundingModeStandard = 0,

127  miopenF8RoundingModeStochastic = 1,

128 } miopenF8RoundingMode_t;

129 #endif

130 

138 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);

139 

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

149 

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

159 

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

174 

183 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);

184 

196 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,

197  miopenAcceleratorQueue_t stream);

198 

205 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);

206 

214 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,

215  miopenAcceleratorQueue_t streamID);

216 

224 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,

225  miopenAcceleratorQueue_t* streamID);

226 

243 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,

244  miopenAllocatorFunction allocator,

245  miopenDeallocatorFunction deallocator,

246  void* allocatorContext);

247 

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

260 

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

270 // CLOSEOUT HANDLE DOXYGEN GROUP

271 

279 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);

280 

288 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);

289 

296 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);

297 

305 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);

306 

314 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);

315 

323 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);

324 

331 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);

332 

336 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);

337 

341 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);

342 

346 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);

347 

351 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);

352 

356 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);

357 

361 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);

362 

367 typedef enum

368 {

369  miopenHalf = 0,

370  miopenFloat = 1,

371  miopenInt32 = 2,

372  miopenInt8 = 3,

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

374  miopenBFloat16 = 5,

376  miopenDouble = 6,

377  miopenFloat8_fnuz = 7,

378  miopenBFloat8_fnuz = 8,

379  miopenInt64 = 9,

380 } miopenDataType_t;

381 

387 typedef enum

388 {

389  miopenTensorNCHW = 0,

390  miopenTensorNHWC = 1,

391  miopenTensorCHWN = 2,

392  miopenTensorNCHWc4 = 3,

393  miopenTensorNCHWc8 = 4,

394  miopenTensorCHWNc4 = 5,

395  miopenTensorCHWNc8 = 6,

396  miopenTensorNCDHW = 7,

397  miopenTensorNDHWC = 8,

398 } miopenTensorLayout_t;

399 

404 typedef enum

405 {

406  miopenIndexUint8 = 0,

407  miopenIndexUint16 = 1,

408  miopenIndexUint32 = 2,

409  miopenIndexUint64 = 3,

410 } miopenIndexType_t;

411 

416 typedef enum

417 {

418  miopenTensorOpAdd = 0,

419  miopenTensorOpMul = 1,

420  miopenTensorOpMin = 2,

421  miopenTensorOpMax = 3,

422 } miopenTensorOp_t;

423 

428 typedef enum

429 {

430  miopenConvolution = 0,

431  miopenTranspose = 1,

432  miopenGroupConv = 2,

433  miopenDepthwise = 3,

434 } miopenConvolutionMode_t;

435 

440 typedef enum

441 {

442  miopenPaddingDefault = 0,

443  miopenPaddingSame = 1,

444  miopenPaddingValid = 2,

445 } miopenPaddingMode_t;

446 

451 typedef enum

452 {

453  miopenPoolingMax = 0,

454  miopenPoolingAverage = 1,

455  miopenPoolingAverageInclusive = 2,

456 } miopenPoolingMode_t;

457 

464 typedef enum

465 {

466  miopenPoolingWorkspaceIndexMask = 0,

467  miopenPoolingWorkspaceIndexImage = 1,

468 } miopenPoolingWorkspaceIndexMode_t;

469 

474 typedef enum

475 {

476  miopenLRNWithinChannel = 0,

477  miopenLRNCrossChannel = 1,

478 } miopenLRNMode_t;

479 #ifdef MIOPEN_BETA_API

484 typedef enum

485 {

486  MIOPEN_ELEMENTWISE_AFFINE = 0,

487  MIOPEN_WEIGHT_BIAS =

488  1,

489  MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =

490  2,

491  MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3,

493  MIOPEN_ELEMENTWISE_AFFINE_T5 =

494  4,

495  MIOPEN_WEIGHT_BIAS_T5 = 5,

497 } miopenNormMode_t;

498 #endif

503 typedef enum

504 {

505  miopenBNPerActivation = 0,

506  miopenBNSpatial = 1,

507 } miopenBatchNormMode_t;

508 

513 typedef enum

514 {

515  miopenActivationPASTHRU = 0,

516  miopenActivationLOGISTIC = 1,

517  miopenActivationTANH = 2,

518  miopenActivationRELU = 3,

519  miopenActivationSOFTRELU = 4,

520  miopenActivationABS = 5,

521  miopenActivationPOWER = 6,

522  miopenActivationCLIPPEDRELU =

523  7,

524  miopenActivationLEAKYRELU =

525  8,

526  miopenActivationELU =

527  9,

529  miopenActivationCLAMP = 10,

530 } miopenActivationMode_t;

531 

536 typedef enum

537 {

538  MIOPEN_SOFTMAX_FAST = 0,

539  MIOPEN_SOFTMAX_ACCURATE = 1,

540  MIOPEN_SOFTMAX_LOG = 2,

541 } miopenSoftmaxAlgorithm_t;

542 

547 typedef enum

548 {

549  MIOPEN_SOFTMAX_MODE_INSTANCE = 0,

550  MIOPEN_SOFTMAX_MODE_CHANNEL =

551  1,

552 } miopenSoftmaxMode_t;

553 

561 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1

562 

567 typedef enum

568 {

569  MIOPEN_REDUCE_TENSOR_ADD = 0,

570  MIOPEN_REDUCE_TENSOR_MUL =

571  1,

572  MIOPEN_REDUCE_TENSOR_MIN =

573  2,

574  MIOPEN_REDUCE_TENSOR_MAX =

575  3,

576  MIOPEN_REDUCE_TENSOR_AMAX =

577  4,

578  MIOPEN_REDUCE_TENSOR_AVG =

579  5,

580  MIOPEN_REDUCE_TENSOR_NORM1 =

581  6,

582  MIOPEN_REDUCE_TENSOR_NORM2 = 7,

584  // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =

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

586 } miopenReduceTensorOp_t;

587 

592 typedef enum

593 {

594  MIOPEN_NOT_PROPAGATE_NAN = 0,

595  MIOPEN_PROPAGATE_NAN = 1,

596 } miopenNanPropagation_t;

597 

602 typedef enum

603 {

604  MIOPEN_REDUCE_TENSOR_NO_INDICES = 0,

605  MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1,

606 } miopenReduceTensorIndices_t;

607 

612 typedef enum

613 {

614  MIOPEN_32BIT_INDICES = 0,

615  MIOPEN_64BIT_INDICES = 1,

616  MIOPEN_16BIT_INDICES = 2,

617  MIOPEN_8BIT_INDICES = 3,

618 } miopenIndicesType_t;

619 

624 typedef enum

625 {

626  MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =

627  0,

630  MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =

631  1,

633 #ifdef MIOPEN_BETA_API

634  MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =

635  2,

639 #else

640 // miopenReserved1 = 2,

641 #endif

642 } miopenConvolutionAttrib_t;

643 

650 typedef enum

651 {

652  miopenConvolutionFindModeNormal =

653  1,

654  miopenConvolutionFindModeFast =

655  2,

658  miopenConvolutionFindModeHybrid =

659  3,

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

663  miopenConvolutionFindModeDynamicHybrid =

664  5,

668  miopenConvolutionFindModeTrustVerify = 6,

669  miopenConvolutionFindModeTrustVerifyFull = 7,

670  miopenConvolutionFindModeDefault =

671  miopenConvolutionFindModeDynamicHybrid

672 } miopenConvolutionFindMode_t;

673 

685 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);

686 

699 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(

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

701 

712 MIOPEN_EXPORT miopenStatus_t

713 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,

714  miopenDataType_t dataType,

715  miopenTensorLayout_t tensorLayout,

716  const int* lens,

717  int num_lens);

737 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptorEx(miopenTensorDescriptor_t tensorDesc,

738  miopenDataType_t dataType,

739  int n,

740  int c,

741  int h,

742  int w,

743  int nStride,

744  int cStride,

745  int hStride,

746  int wStride);

747 

764 MIOPEN_EXPORT miopenStatus_t miopenGet4dTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

765  miopenDataType_t* dataType,

766  int* n,

767  int* c,

768  int* h,

769  int* w,

770  int* nStride,

771  int* cStride,

772  int* hStride,

773  int* wStride);

774 

785 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

786  miopenDataType_t dataType,

787  int nbDims,

788  const int* dimsA,

789  const int* stridesA);

790 

791 #ifdef MIOPEN_BETA_API

794 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,

795  miopenDataType_t dataType,

796  int nbDims,

797  const size_t* dimsA,

798  const size_t* stridesA);

799 #endif

800 

801 #ifdef MIOPEN_BETA_API

811 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,

812  miopenDataType_t cast_type);

813 #endif

814 

823 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,

824  int* size);

825 

834 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,

835  miopenDataType_t* dataType,

836  int* dimsA,

837  int* stridesA);

838 

844 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);

845 

852 MIOPEN_EXPORT miopenStatus_t

853 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);

854 

860 MIOPEN_EXPORT miopenStatus_t

861 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);

862 

882 MIOPEN_EXPORT miopenStatus_t miopenOpTensor(miopenHandle_t handle,

883  miopenTensorOp_t tensorOp,

884  const void* alpha1,

885  const miopenTensorDescriptor_t aDesc,

886  const void* A,

887  const void* alpha2,

888  const miopenTensorDescriptor_t bDesc,

889  const void* B,

890  const void* beta,

891  const miopenTensorDescriptor_t cDesc,

892  void* C);

893 

904 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,

905  const miopenTensorDescriptor_t yDesc,

906  void* y,

907  const void* alpha);

908 

919 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,

920  const miopenTensorDescriptor_t yDesc,

921  void* y,

922  const void* alpha);

923 

930 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,

931  size_t* numBytes);

932 

950 MIOPEN_EXPORT miopenStatus_t miopenTransformTensor(miopenHandle_t handle,

951  const void* alpha,

952  const miopenTensorDescriptor_t xDesc,

953  const void* x,

954  const void* beta,

955  const miopenTensorDescriptor_t yDesc,

956  void* y);

957 

959 // CLOSEOUT TENSOR DOXYGEN GROUP

960 

971 MIOPEN_EXPORT miopenStatus_t

972 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);

973 

989 MIOPEN_EXPORT miopenStatus_t miopenInitConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

990  miopenConvolutionMode_t c_mode,

991  int pad_h,

992  int pad_w,

993  int stride_h,

994  int stride_w,

995  int dilation_h,

996  int dilation_w);

997 

1008 MIOPEN_EXPORT miopenStatus_t

1009 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1010  int spatialDim,

1011  const int* padA,

1012  const int* strideA,

1013  const int* dilationA,

1014  miopenConvolutionMode_t c_mode);

1015 

1022 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,

1023  int* spatialDim);

1024 

1040 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc,

1041  miopenConvolutionMode_t* c_mode,

1042  int* pad_h,

1043  int* pad_w,

1044  int* stride_h,

1045  int* stride_w,

1046  int* dilation_h,

1047  int* dilation_w);

1048 

1060 MIOPEN_EXPORT miopenStatus_t

1061 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,

1062  int requestedSpatialDim,

1063  int* spatialDim,

1064  int* padA,

1065  int* strideA,

1066  int* dilationA,

1067  miopenConvolutionMode_t* c_mode);

1068 

1075 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1076  int* groupCount);

1077 

1091 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,

1092  int groupCount);

1093 

1106 MIOPEN_EXPORT miopenStatus_t

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

1108 

1121 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(

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

1123 

1141 MIOPEN_EXPORT miopenStatus_t

1142 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1143  const miopenTensorDescriptor_t inputTensorDesc,

1144  const miopenTensorDescriptor_t filterDesc,

1145  int* n,

1146  int* c,

1147  int* h,

1148  int* w);

1149 

1163 MIOPEN_EXPORT miopenStatus_t

1164 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,

1165  const miopenTensorDescriptor_t inputTensorDesc,

1166  const miopenTensorDescriptor_t filterDesc,

1167  int* nDim,

1168  int* outputTensorDimA);

1169 

1175 MIOPEN_EXPORT miopenStatus_t

1176 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);

1177 

1184 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1185  const miopenConvolutionAttrib_t attr,

1186  int value);

1187 

1194 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,

1195  const miopenConvolutionAttrib_t attr,

1196  int* value);

1197 

1211 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,

1212  miopenConvolutionFindMode_t findMode);

1213 

1220 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(

1221  const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);

1222 

1227 typedef enum

1228 {

1229  miopenConvolutionFwdAlgoGEMM = 0,

1230  miopenConvolutionFwdAlgoDirect = 1,

1231  miopenConvolutionFwdAlgoFFT = 2,

1232  miopenConvolutionFwdAlgoWinograd = 3,

1233  miopenConvolutionFwdAlgoImplicitGEMM = 5,

1234 } miopenConvFwdAlgorithm_t;

1235 

1239 typedef enum

1240 {

1241  miopenConvolutionBwdWeightsAlgoGEMM = 0,

1242  miopenConvolutionBwdWeightsAlgoDirect = 1,

1243  miopenConvolutionBwdWeightsAlgoWinograd = 3,

1244  miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5,

1245 } miopenConvBwdWeightsAlgorithm_t;

1246 

1250 typedef enum

1251 {

1252  miopenConvolutionBwdDataAlgoGEMM = 0,

1253  miopenConvolutionBwdDataAlgoDirect = 1,

1254  miopenConvolutionBwdDataAlgoFFT = 2,

1255  miopenConvolutionBwdDataAlgoWinograd = 3,

1256  miopenTransposeBwdDataAlgoGEMM =

1257  4,

1258  miopenConvolutionBwdDataAlgoImplicitGEMM = 5,

1259 } miopenConvBwdDataAlgorithm_t;

1260 

1264 typedef enum

1265 {

1266  miopenConvolutionAlgoGEMM = 0,

1267  miopenConvolutionAlgoDirect = 1,

1268  miopenConvolutionAlgoFFT = 2,

1269  miopenConvolutionAlgoWinograd = 3,

1270  miopenConvolutionAlgoImplicitGEMM = 5,

1271 } miopenConvAlgorithm_t;

1272 

1279 typedef struct

1280 {

1281  union

1282  {

1283  miopenConvFwdAlgorithm_t fwd_algo;

1284  miopenConvBwdWeightsAlgorithm_t bwd_weights_algo;

1286  miopenConvBwdDataAlgorithm_t

1287  bwd_data_algo;

1288  };

1289 

1290  float time;

1291  size_t memory;

1293 } miopenConvAlgoPerf_t;

1294 

1303 typedef struct

1304 {

1305  float time;

1308  size_t workspace_size;

1310  uint64_t solution_id;

1311  miopenConvAlgorithm_t algorithm;

1313 } miopenConvSolution_t;

1314 

1330 MIOPEN_EXPORT miopenStatus_t

1331 miopenConvolutionForwardGetSolutionCount(miopenHandle_t handle,

1332  const miopenTensorDescriptor_t wDesc,

1333  const miopenTensorDescriptor_t xDesc,

1334  const miopenConvolutionDescriptor_t convDesc,

1335  const miopenTensorDescriptor_t yDesc,

1336  size_t* solutionCount);

1337 

1361 MIOPEN_EXPORT miopenStatus_t

1362 miopenConvolutionForwardGetSolution(miopenHandle_t handle,

1363  const miopenTensorDescriptor_t wDesc,

1364  const miopenTensorDescriptor_t xDesc,

1365  const miopenConvolutionDescriptor_t convDesc,

1366  const miopenTensorDescriptor_t yDesc,

1367  const size_t maxSolutionCount,

1368  size_t* solutionCount,

1369  miopenConvSolution_t* solutions);

1370 

1388 MIOPEN_EXPORT miopenStatus_t

1389 miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,

1390  const miopenTensorDescriptor_t wDesc,

1391  const miopenTensorDescriptor_t xDesc,

1392  const miopenConvolutionDescriptor_t convDesc,

1393  const miopenTensorDescriptor_t yDesc,

1394  const uint64_t solution_id,

1395  size_t* workSpaceSize);

1396 

1414 MIOPEN_EXPORT miopenStatus_t

1415 miopenConvolutionForwardCompileSolution(miopenHandle_t handle,

1416  const miopenTensorDescriptor_t wDesc,

1417  const miopenTensorDescriptor_t xDesc,

1418  const miopenConvolutionDescriptor_t convDesc,

1419  const miopenTensorDescriptor_t yDesc,

1420  const uint64_t solution_id);

1421 

1439 MIOPEN_EXPORT miopenStatus_t

1440 miopenConvolutionForwardImmediate(miopenHandle_t handle,

1441  const miopenTensorDescriptor_t wDesc,

1442  const void* w,

1443  const miopenTensorDescriptor_t xDesc,

1444  const void* x,

1445  const miopenConvolutionDescriptor_t convDesc,

1446  const miopenTensorDescriptor_t yDesc,

1447  void* y,

1448  void* workSpace,

1449  size_t workSpaceSize,

1450  const uint64_t solution_id);

1451 

1469 MIOPEN_EXPORT miopenStatus_t

1470 miopenConvolutionBackwardDataGetSolutionCount(miopenHandle_t handle,

1471  const miopenTensorDescriptor_t dyDesc,

1472  const miopenTensorDescriptor_t wDesc,

1473  const miopenConvolutionDescriptor_t convDesc,

1474  const miopenTensorDescriptor_t dxDesc,

1475  size_t* solutionCount);

1476 

1501 MIOPEN_EXPORT miopenStatus_t

1502 miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,

1503  const miopenTensorDescriptor_t dyDesc,

1504  const miopenTensorDescriptor_t wDesc,

1505  const miopenConvolutionDescriptor_t convDesc,

1506  const miopenTensorDescriptor_t dxDesc,

1507  const size_t maxSolutionCount,

1508  size_t* solutionCount,

1509  miopenConvSolution_t* solutions);

1510 

1528 MIOPEN_EXPORT miopenStatus_t

1529 miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,

1530  const miopenTensorDescriptor_t dyDesc,

1531  const miopenTensorDescriptor_t wDesc,

1532  const miopenConvolutionDescriptor_t convDesc,

1533  const miopenTensorDescriptor_t dxDesc,

1534  const uint64_t solution_id,

1535  size_t* workSpaceSize);

1536 

1555 MIOPEN_EXPORT miopenStatus_t

1556 miopenConvolutionBackwardDataCompileSolution(miopenHandle_t handle,

1557  const miopenTensorDescriptor_t dyDesc,

1558  const miopenTensorDescriptor_t wDesc,

1559  const miopenConvolutionDescriptor_t convDesc,

1560  const miopenTensorDescriptor_t dxDesc,

1561  const uint64_t solution_id);

1562 

1580 MIOPEN_EXPORT miopenStatus_t

1581 miopenConvolutionBackwardDataImmediate(miopenHandle_t handle,

1582  const miopenTensorDescriptor_t dyDesc,

1583  const void* dy,

1584  const miopenTensorDescriptor_t wDesc,

1585  const void* w,

1586  const miopenConvolutionDescriptor_t convDesc,

1587  const miopenTensorDescriptor_t dxDesc,

1588  void* dx,

1589  void* workSpace,

1590  size_t workSpaceSize,

1591  const uint64_t solution_id);

1592 

1610 MIOPEN_EXPORT miopenStatus_t

1611 miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,

1612  const miopenTensorDescriptor_t dyDesc,

1613  const miopenTensorDescriptor_t xDesc,

1614  const miopenConvolutionDescriptor_t convDesc,

1615  const miopenTensorDescriptor_t dwDesc,

1616  size_t* solutionCount);

1617 

1641 MIOPEN_EXPORT miopenStatus_t

1642 miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,

1643  const miopenTensorDescriptor_t dyDesc,

1644  const miopenTensorDescriptor_t xDesc,

1645  const miopenConvolutionDescriptor_t convDesc,

1646  const miopenTensorDescriptor_t dwDesc,

1647  const size_t maxSolutionCount,

1648  size_t* solutionCount,

1649  miopenConvSolution_t* solutions);

1650 

1668 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize(

1669  miopenHandle_t handle,

1670  const miopenTensorDescriptor_t dyDesc,

1671  const miopenTensorDescriptor_t xDesc,

1672  const miopenConvolutionDescriptor_t convDesc,

1673  const miopenTensorDescriptor_t dwDesc,

1674  const uint64_t solution_id,

1675  size_t* workSpaceSize);

1676 

1694 MIOPEN_EXPORT miopenStatus_t

1695 miopenConvolutionBackwardWeightsCompileSolution(miopenHandle_t handle,

1696  const miopenTensorDescriptor_t dyDesc,

1697  const miopenTensorDescriptor_t xDesc,

1698  const miopenConvolutionDescriptor_t convDesc,

1699  const miopenTensorDescriptor_t dwDesc,

1700  const uint64_t solution_id);

1701 

1720 MIOPEN_EXPORT miopenStatus_t

1721 miopenConvolutionBackwardWeightsImmediate(miopenHandle_t handle,

1722  const miopenTensorDescriptor_t dyDesc,

1723  const void* dy,

1724  const miopenTensorDescriptor_t xDesc,

1725  const void* x,

1726  const miopenConvolutionDescriptor_t convDesc,

1727  const miopenTensorDescriptor_t dwDesc,

1728  void* dw,

1729  void* workSpace,

1730  size_t workSpaceSize,

1731  const uint64_t solution_id);

1732 

1759 MIOPEN_EXPORT miopenStatus_t

1760 miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,

1761  const miopenTensorDescriptor_t wDesc,

1762  const miopenTensorDescriptor_t xDesc,

1763  const miopenConvolutionDescriptor_t convDesc,

1764  const miopenTensorDescriptor_t yDesc,

1765  size_t* workSpaceSize);

1766 

1810 MIOPEN_EXPORT miopenStatus_t

1811 miopenFindConvolutionForwardAlgorithm(miopenHandle_t handle,

1812  const miopenTensorDescriptor_t xDesc,

1813  const void* x,

1814  const miopenTensorDescriptor_t wDesc,

1815  const void* w,

1816  const miopenConvolutionDescriptor_t convDesc,

1817  const miopenTensorDescriptor_t yDesc,

1818  void* y,

1819  const int requestAlgoCount,

1820  int* returnedAlgoCount,

1821  miopenConvAlgoPerf_t* perfResults,

1822  void* workSpace,

1823  size_t workSpaceSize,

1824  bool exhaustiveSearch);

1825 

1860 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForward(miopenHandle_t handle,

1861  const void* alpha,

1862  const miopenTensorDescriptor_t xDesc,

1863  const void* x,

1864  const miopenTensorDescriptor_t wDesc,

1865  const void* w,

1866  const miopenConvolutionDescriptor_t convDesc,

1867  miopenConvFwdAlgorithm_t algo,

1868  const void* beta,

1869  const miopenTensorDescriptor_t yDesc,

1870  void* y,

1871  void* workSpace,

1872  size_t workSpaceSize);

1873 

1889 MIOPEN_EXPORT miopenStatus_t miopenConvolutionForwardBias(miopenHandle_t handle,

1890  const void* alpha,

1891  const miopenTensorDescriptor_t bDesc,

1892  const void* b,

1893  const void* beta,

1894  const miopenTensorDescriptor_t yDesc,

1895  void* y);

1896 

1924 MIOPEN_EXPORT miopenStatus_t

1925 miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,

1926  const miopenTensorDescriptor_t dyDesc,

1927  const miopenTensorDescriptor_t wDesc,

1928  const miopenConvolutionDescriptor_t convDesc,

1929  const miopenTensorDescriptor_t dxDesc,

1930  size_t* workSpaceSize);

1931 

1975 MIOPEN_EXPORT miopenStatus_t

1976 miopenFindConvolutionBackwardDataAlgorithm(miopenHandle_t handle,

1977  const miopenTensorDescriptor_t dyDesc,

1978  const void* dy,

1979  const miopenTensorDescriptor_t wDesc,

1980  const void* w,

1981  const miopenConvolutionDescriptor_t convDesc,

1982  const miopenTensorDescriptor_t dxDesc,

1983  void* dx,

1984  const int requestAlgoCount,

1985  int* returnedAlgoCount,

1986  miopenConvAlgoPerf_t* perfResults,

1987  void* workSpace,

1988  size_t workSpaceSize,

1989  bool exhaustiveSearch);

1990 

2024 MIOPEN_EXPORT miopenStatus_t

2025 miopenConvolutionBackwardData(miopenHandle_t handle,

2026  const void* alpha,

2027  const miopenTensorDescriptor_t dyDesc,

2028  const void* dy,

2029  const miopenTensorDescriptor_t wDesc,

2030  const void* w,

2031  const miopenConvolutionDescriptor_t convDesc,

2032  miopenConvBwdDataAlgorithm_t algo,

2033  const void* beta,

2034  const miopenTensorDescriptor_t dxDesc,

2035  void* dx,

2036  void* workSpace,

2037  size_t workSpaceSize);

2038 

2066 MIOPEN_EXPORT miopenStatus_t

2067 miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,

2068  const miopenTensorDescriptor_t dyDesc,

2069  const miopenTensorDescriptor_t xDesc,

2070  const miopenConvolutionDescriptor_t convDesc,

2071  const miopenTensorDescriptor_t dwDesc,

2072  size_t* workSpaceSize);

2073 

2117 MIOPEN_EXPORT miopenStatus_t

2118 miopenFindConvolutionBackwardWeightsAlgorithm(miopenHandle_t handle,

2119  const miopenTensorDescriptor_t dyDesc,

2120  const void* dy,

2121  const miopenTensorDescriptor_t xDesc,

2122  const void* x,

2123  const miopenConvolutionDescriptor_t convDesc,

2124  const miopenTensorDescriptor_t dwDesc,

2125  void* dw,

2126  const int requestAlgoCount,

2127  int* returnedAlgoCount,

2128  miopenConvAlgoPerf_t* perfResults,

2129  void* workSpace,

2130  size_t workSpaceSize,

2131  bool exhaustiveSearch);

2132 

2166 MIOPEN_EXPORT miopenStatus_t

2167 miopenConvolutionBackwardWeights(miopenHandle_t handle,

2168  const void* alpha,

2169  const miopenTensorDescriptor_t dyDesc,

2170  const void* dy,

2171  const miopenTensorDescriptor_t xDesc,

2172  const void* x,

2173  const miopenConvolutionDescriptor_t convDesc,

2174  miopenConvBwdWeightsAlgorithm_t algo,

2175  const void* beta,

2176  const miopenTensorDescriptor_t dwDesc,

2177  void* dw,

2178  void* workSpace,

2179  size_t workSpaceSize);

2180 

2196 MIOPEN_EXPORT miopenStatus_t miopenConvolutionBackwardBias(miopenHandle_t handle,

2197  const void* alpha,

2198  const miopenTensorDescriptor_t dyDesc,

2199  const void* dy,

2200  const void* beta,

2201  const miopenTensorDescriptor_t dbDesc,

2202  void* db);

2203 

2205 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP

2206 

2207 // Pooling APIs

2218 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);

2219 

2228 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2229  miopenIndexType_t index_type);

2230 

2238 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,

2239  miopenIndexType_t* index_type);

2240 

2248 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(

2249  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);

2250 

2257 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(

2258  miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);

2259 

2274 MIOPEN_EXPORT miopenStatus_t miopenSet2dPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2275  miopenPoolingMode_t mode,

2276  int windowHeight,

2277  int windowWidth,

2278  int pad_h,

2279  int pad_w,

2280  int stride_h,

2281  int stride_w);

2282 

2297 MIOPEN_EXPORT miopenStatus_t miopenGet2dPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2298  miopenPoolingMode_t* mode,

2299  int* windowHeight,

2300  int* windowWidth,

2301  int* pad_h,

2302  int* pad_w,

2303  int* stride_h,

2304  int* stride_w);

2305 

2320 MIOPEN_EXPORT miopenStatus_t

2321 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2322  const miopenTensorDescriptor_t tensorDesc,

2323  int* n,

2324  int* c,

2325  int* h,

2326  int* w);

2327 

2343 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,

2344  const miopenPoolingMode_t mode,

2345  int nbDims,

2346  const int* windowDimA,

2347  const int* padA,

2348  const int* stridesA);

2349 

2366 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,

2367  int nbDimsRequested,

2368  miopenPoolingMode_t* mode,

2369  int* nbDims,

2370  int* windowDimA,

2371  int* padA,

2372  int* stridesA);

2373 

2386 MIOPEN_EXPORT miopenStatus_t

2387 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,

2388  const miopenTensorDescriptor_t tensorDesc,

2389  int dims,

2390  int* tensorDimArr);

2391 

2404 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2405  size_t* workSpaceSize);

2406 

2419 MIOPEN_EXPORT miopenStatus_t

2420 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,

2421  const miopenTensorDescriptor_t yDesc,

2422  size_t* workSpaceSize);

2423 

2444 MIOPEN_EXPORT miopenStatus_t miopenPoolingForward(miopenHandle_t handle,

2445  const miopenPoolingDescriptor_t poolDesc,

2446  const void* alpha,

2447  const miopenTensorDescriptor_t xDesc,

2448  const void* x,

2449  const void* beta,

2450  const miopenTensorDescriptor_t yDesc,

2451  void* y,

2452  bool do_backward,

2453  void* workSpace,

2454  size_t workSpaceSize);

2455 

2476 MIOPEN_EXPORT miopenStatus_t miopenPoolingBackward(miopenHandle_t handle,

2477  const miopenPoolingDescriptor_t poolDesc,

2478  const void* alpha,

2479  const miopenTensorDescriptor_t yDesc,

2480  const void* y,

2481  const miopenTensorDescriptor_t dyDesc,

2482  const void* dy,

2483  const miopenTensorDescriptor_t xDesc,

2484  const void* x,

2485  const void* beta,

2486  const miopenTensorDescriptor_t dxDesc,

2487  void* dx,

2488  void* workSpace);

2489 

2495 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);

2496 

2498 // CLOSEOUT POOLING DOXYGEN GROUP

2499 

2500 // LRN APIs

2510 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);

2511 

2525 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2526  miopenLRNMode_t mode,

2527  unsigned int lrnN,

2528  double lrnAlpha,

2529  double lrnBeta,

2530  double lrnK);

2531 

2544 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,

2545  miopenLRNMode_t* mode,

2546  unsigned int* lrnN,

2547  double* lrnAlpha,

2548  double* lrnBeta,

2549  double* lrnK);

2550 

2560 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,

2561  size_t* workSpaceSize);

2562 

2581 MIOPEN_EXPORT miopenStatus_t miopenLRNForward(miopenHandle_t handle,

2582  const miopenLRNDescriptor_t lrnDesc,

2583  const void* alpha,

2584  const miopenTensorDescriptor_t xDesc,

2585  const void* x,

2586  const void* beta,

2587  const miopenTensorDescriptor_t yDesc,

2588  void* y,

2589  bool do_backward,

2590  void* workSpace);

2591 

2609 MIOPEN_EXPORT miopenStatus_t miopenLRNBackward(miopenHandle_t handle,

2610  const miopenLRNDescriptor_t lrnDesc,

2611  const void* alpha,

2612  const miopenTensorDescriptor_t yDesc,

2613  const void* y,

2614  const miopenTensorDescriptor_t dyDesc,

2615  const void* dy,

2616  const miopenTensorDescriptor_t xDesc,

2617  const void* x,

2618  const void* beta,

2619  const miopenTensorDescriptor_t dxDesc,

2620  void* dx,

2621  const void* workSpace);

2622 

2628 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);

2629 

2631 // CLOSEOUT LRN DOXYGEN GROUP

2632 

2633 #ifdef MIOPEN_BETA_API

2634 // LayerNorm APIs

2659 MIOPEN_EXPORT miopenStatus_t miopenLayerNormForward(miopenHandle_t handle,

2660  miopenNormMode_t mode,

2661  const miopenTensorDescriptor_t xDesc,

2662  const void* x,

2663  const miopenTensorDescriptor_t weightDesc,

2664  const void* weight,

2665  const miopenTensorDescriptor_t biasDesc,

2666  const void* bias,

2667  const float epsilon,

2668  const int32_t normalized_dim,

2669  const miopenTensorDescriptor_t yDesc,

2670  void* y,

2671  const miopenTensorDescriptor_t meanDesc,

2672  void* mean,

2673  const miopenTensorDescriptor_t rstdDesc,

2674  void* rstd);

2675 

2693 MIOPEN_EXPORT miopenStatus_t

2694 miopenGetLayerNormBackwardWorkspaceSize(miopenHandle_t handle,

2695  miopenNormMode_t mode,

2696  const miopenTensorDescriptor_t dyDesc,

2697  const miopenTensorDescriptor_t xDesc,

2698  const miopenTensorDescriptor_t weightDesc,

2699  const miopenTensorDescriptor_t meanDesc,

2700  const miopenTensorDescriptor_t rstdDesc,

2701  const int32_t normalized_dim,

2702  const miopenTensorDescriptor_t dxDesc,

2703  const miopenTensorDescriptor_t dwDesc,

2704  const miopenTensorDescriptor_t dbDesc,

2705  size_t* sizeInBytes);

2706 

2732 MIOPEN_EXPORT miopenStatus_t miopenLayerNormBackward(miopenHandle_t handle,

2733  miopenNormMode_t mode,

2734  void* workspace,

2735  size_t workspaceSizeInBytes,

2736  const miopenTensorDescriptor_t dyDesc,

2737  const void* dy,

2738  const miopenTensorDescriptor_t xDesc,

2739  const void* x,

2740  const miopenTensorDescriptor_t weightDesc,

2741  const void* weight,

2742  const miopenTensorDescriptor_t meanDesc,

2743  const void* mean,

2744  const miopenTensorDescriptor_t rstdDesc,

2745  const void* rstd,

2746  const int32_t normalized_dim,

2747  const miopenTensorDescriptor_t dxDesc,

2748  void* dx,

2749  const miopenTensorDescriptor_t dwDesc,

2750  void* dw,

2751  const miopenTensorDescriptor_t dbDesc,

2752  void* db);

2753 

2755 // CLOSEOUT LAYERNORM DOXYGEN GROUP

2756 #endif

2757 

2758 #ifdef MIOPEN_BETA_API

2759 // Cat APIs

2775 MIOPEN_EXPORT miopenStatus_t miopenCatForward(miopenHandle_t handle,

2776  const int32_t xCount,

2777  const miopenTensorDescriptor_t* xDescs,

2778  const void* const* xs,

2779  const miopenTensorDescriptor_t yDesc,

2780  void* y,

2781  const int32_t dim);

2782 

2784 // CLOSEOUT CAT DOXYGEN GROUP

2785 #endif

2786 

2787 // Batch-Normalization APIs

2809 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,

2810  const miopenTensorDescriptor_t xDesc,

2811  miopenBatchNormMode_t bn_mode);

2812 

2851 MIOPEN_EXPORT miopenStatus_t

2852 miopenBatchNormalizationForwardTraining(miopenHandle_t handle,

2853  miopenBatchNormMode_t bn_mode,

2854  void* alpha,

2855  void* beta,

2856  const miopenTensorDescriptor_t xDesc,

2857  const void* x,

2858  const miopenTensorDescriptor_t yDesc,

2859  void* y,

2860  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

2861  void* bnScale,

2862  void* bnBias,

2863  double expAvgFactor,

2864  void* resultRunningMean,

2865  void* resultRunningVariance,

2866  double epsilon,

2867  void* resultSaveMean,

2868  void* resultSaveInvVariance);

2909 MIOPEN_EXPORT miopenStatus_t

2910 miopenBatchNormalizationForwardTraining_V2(miopenHandle_t handle,

2911  miopenBatchNormMode_t bn_mode,

2912  void* alpha,

2913  void* beta,

2914  const miopenTensorDescriptor_t xDesc,

2915  const void* x,

2916  const miopenTensorDescriptor_t yDesc,

2917  void* y,

2918  const miopenTensorDescriptor_t scaleDesc,

2919  const miopenTensorDescriptor_t biasVarDesc,

2920  const miopenTensorDescriptor_t savedMeanDesc,

2921  const miopenTensorDescriptor_t savedVarDesc,

2922  void* bnScale,

2923  void* bnBias,

2924  double expAvgFactor,

2925  void* resultRunningMean,

2926  void* resultRunningVariance,

2927  double epsilon,

2928  void* resultSaveMean,

2929  void* resultSaveInvVariance);

2971 MIOPEN_EXPORT miopenStatus_t

2972 miopenBatchNormForwardTrainingActivation(miopenHandle_t handle,

2973  miopenBatchNormMode_t bn_mode,

2974  void* alpha,

2975  void* beta,

2976  const miopenTensorDescriptor_t xDesc,

2977  const void* x,

2978  const miopenTensorDescriptor_t yDesc,

2979  void* y,

2980  const miopenTensorDescriptor_t scaleDesc,

2981  const miopenTensorDescriptor_t biasVarDesc,

2982  const miopenTensorDescriptor_t savedMeanDesc,

2983  const miopenTensorDescriptor_t savedVarDesc,

2984  void* bnScale,

2985  void* bnBias,

2986  double expAvgFactor,

2987  void* resultRunningMean,

2988  void* resultRunningVariance,

2989  double epsilon,

2990  void* resultSaveMean,

2991  void* resultSaveInvVariance,

2992  const miopenActivationDescriptor_t activDesc);

2993 

3023 MIOPEN_EXPORT miopenStatus_t

3024 miopenBatchNormalizationForwardInference(miopenHandle_t handle,

3025  miopenBatchNormMode_t bn_mode,

3026  void* alpha,

3027  void* beta,

3028  const miopenTensorDescriptor_t xDesc,

3029  const void* x,

3030  const miopenTensorDescriptor_t yDesc,

3031  void* y,

3032  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc,

3033  void* bnScale,

3034  void* bnBias,

3035  void* estimatedMean,

3036  void* estimatedVariance,

3037  double epsilon);

3038 

3070 MIOPEN_EXPORT miopenStatus_t

3071 miopenBatchNormalizationForwardInference_V2(miopenHandle_t handle,

3072  miopenBatchNormMode_t bn_mode,

3073  void* alpha,

3074  void* beta,

3075  const miopenTensorDescriptor_t xDesc,

3076  const void* x,

3077  const miopenTensorDescriptor_t yDesc,

3078  void* y,

3079  const miopenTensorDescriptor_t scaleDesc,

3080  const miopenTensorDescriptor_t biasDesc,

3081  const miopenTensorDescriptor_t estMeanDesc,

3082  const miopenTensorDescriptor_t estVarianceDesc,

3083  void* bnScale,

3084  void* bnBias,

3085  void* estimatedMean,

3086  void* estimatedVariance,

3087  double epsilon);

3088 

3121 MIOPEN_EXPORT miopenStatus_t

3122 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,

3123  miopenBatchNormMode_t bn_mode,

3124  void* alpha,

3125  void* beta,

3126  const miopenTensorDescriptor_t xDesc,

3127  const void* x,

3128  const miopenTensorDescriptor_t yDesc,

3129  void* y,

3130  const miopenTensorDescriptor_t scaleDesc,

3131  const miopenTensorDescriptor_t biasDesc,

3132  const miopenTensorDescriptor_t estMeanDesc,

3133  const miopenTensorDescriptor_t estVarianceDesc,

3134  void* bnScale,

3135  void* bnBias,

3136  void* estimatedMean,

3137  void* estimatedVariance,

3138  double epsilon,

3139  const miopenActivationDescriptor_t activDesc);

3140 

3175 MIOPEN_EXPORT miopenStatus_t

3176 miopenBatchNormalizationBackward(miopenHandle_t handle,

3177  miopenBatchNormMode_t bn_mode,

3178  const void* alphaDataDiff,

3179  const void* betaDataDiff,

3180  const void* alphaParamDiff,

3181  const void* betaParamDiff,

3182  const miopenTensorDescriptor_t xDesc,

3183  const void* x,

3184  const miopenTensorDescriptor_t dyDesc,

3185  const void* dy,

3186  const miopenTensorDescriptor_t dxDesc,

3187  void* dx,

3188  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,

3189  const void* bnScale,

3190  void* resultBnScaleDiff,

3191  void* resultBnBiasDiff,

3192  double epsilon,

3193  const void* savedMean,

3194  const void* savedInvVariance);

3195 

3234 MIOPEN_EXPORT miopenStatus_t

3235 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,

3236  miopenBatchNormMode_t bn_mode,

3237  const void* alphaDataDiff,

3238  const void* betaDataDiff,

3239  const void* alphaParamDiff,

3240  const void* betaParamDiff,

3241  const miopenTensorDescriptor_t xDesc,

3242  const void* x,

3243  const miopenTensorDescriptor_t dyDesc,

3244  const void* dy,

3245  const miopenTensorDescriptor_t dxDesc,

3246  void* dx,

3247  const miopenTensorDescriptor_t scaleDesc,

3248  const miopenTensorDescriptor_t biasDesc,

3249  const miopenTensorDescriptor_t savedMeanDesc,

3250  const miopenTensorDescriptor_t savedVarDesc,

3251  const void* bnScale,

3252  void* resultBnScaleDiff,

3253  void* resultBnBiasDiff,

3254  double epsilon,

3255  const void* savedMean,

3256  const void* savedInvVariance);

3257 

3298 MIOPEN_EXPORT miopenStatus_t

3299 miopenBatchNormBackwardActivation(miopenHandle_t handle,

3300  miopenBatchNormMode_t bn_mode,

3301  const void* alphaDataDiff,

3302  const void* betaDataDiff,

3303  const void* alphaParamDiff,

3304  const void* betaParamDiff,

3305  const miopenTensorDescriptor_t xDesc,

3306  const void* x,

3307  const miopenTensorDescriptor_t dyDesc,

3308  const void* dy,

3309  const miopenTensorDescriptor_t dxDesc,

3310  void* dx,

3311  const miopenTensorDescriptor_t scaleDesc,

3312  const miopenTensorDescriptor_t biasDesc,

3313  const miopenTensorDescriptor_t savedMeanDesc,

3314  const miopenTensorDescriptor_t savedVarianceDesc,

3315  const void* bnScale,

3316  const void* bnBias,

3317  void* resultBnScaleDiff,

3318  void* resultBnBiasDiff,

3319  double epsilon,

3320  const void* savedMean,

3321  const void* savedInvVariance,

3322  const miopenActivationDescriptor_t activDesc);

3324 // CLOSEOUT BATCHNORM DOXYGEN GROUP

3325 

3326 // Activation APIs

3336 MIOPEN_EXPORT miopenStatus_t

3337 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

3338 

3350 MIOPEN_EXPORT miopenStatus_t

3351 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3352  miopenActivationMode_t mode,

3353  double activAlpha,

3354  double activBeta,

3355  double activGamma);

3356 

3368 MIOPEN_EXPORT miopenStatus_t

3369 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3370  miopenActivationMode_t* mode,

3371  double* activAlpha,

3372  double* activBeta,

3373  double* activGamma);

3374 

3387 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,

3388  const miopenActivationDescriptor_t activDesc,

3389  const void* alpha,

3390  const miopenTensorDescriptor_t xDesc,

3391  const void* x,

3392  const void* beta,

3393  const miopenTensorDescriptor_t yDesc,

3394  void* y);

3395 

3412 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,

3413  const miopenActivationDescriptor_t activDesc,

3414  const void* alpha,

3415  const miopenTensorDescriptor_t yDesc,

3416  const void* y,

3417  const miopenTensorDescriptor_t dyDesc,

3418  const void* dy,

3419  const miopenTensorDescriptor_t xDesc,

3420  const void* x,

3421  const void* beta,

3422  const miopenTensorDescriptor_t dxDesc,

3423  void* dx);

3424 

3430 MIOPEN_EXPORT miopenStatus_t

3431 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

3432 

3434 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3435 

3436 #ifdef MIOPEN_BETA_API

3452 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,

3453  const miopenTensorDescriptor_t inputDesc,

3454  const void* input,

3455  const miopenTensorDescriptor_t outputDesc,

3456  void* output,

3457  const uint32_t dim);

3458 

3471 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,

3472  const miopenTensorDescriptor_t inputDesc,

3473  const void* input,

3474  const miopenTensorDescriptor_t outputGradDesc,

3475  const void* outputGrad,

3476  const miopenTensorDescriptor_t inputGradDesc,

3477  void* inputGrad,

3478  const uint32_t dim);

3479 

3481 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3482 #endif // MIOPEN_BETA_API

3483 

3484 // Softmax APIs

3502 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,

3503  const void* alpha,

3504  const miopenTensorDescriptor_t xDesc,

3505  const void* x,

3506  const void* beta,

3507  const miopenTensorDescriptor_t yDesc,

3508  void* y);

3509 

3525 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,

3526  const void* alpha,

3527  const miopenTensorDescriptor_t yDesc,

3528  const void* y,

3529  const miopenTensorDescriptor_t dyDesc,

3530  const void* dy,

3531  const void* beta,

3532  const miopenTensorDescriptor_t dxDesc,

3533  void* dx);

3534 

3548 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,

3549  const void* alpha,

3550  const miopenTensorDescriptor_t xDesc,

3551  const void* x,

3552  const void* beta,

3553  const miopenTensorDescriptor_t yDesc,

3554  void* y,

3555  miopenSoftmaxAlgorithm_t algorithm,

3556  miopenSoftmaxMode_t mode);

3557 

3573 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,

3574  const void* alpha,

3575  const miopenTensorDescriptor_t yDesc,

3576  const void* y,

3577  const miopenTensorDescriptor_t dyDesc,

3578  const void* dy,

3579  const void* beta,

3580  const miopenTensorDescriptor_t dxDesc,

3581  void* dx,

3582  miopenSoftmaxAlgorithm_t algorithm,

3583  miopenSoftmaxMode_t mode);

3584 

3586 // CLOSEOUT SOFTMAX DOXYGEN GROUP

3587 

3591 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3592 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3593 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3594 

3603 typedef enum

3604 {

3605  miopenVerticalFusion = 0,

3606  miopenHorizontalFusion = 1,

3607 } miopenFusionDirection_t;

3608 

3616 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3617  const miopenFusionDirection_t fuseDirection,

3618  const miopenTensorDescriptor_t inputDesc);

3619 

3625 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3626 

3633 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3634  miopenFusionPlanDescriptor_t fusePlanDesc);

3635 

3646 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3647  const int op_idx,

3648  miopenFusionOpDescriptor_t* op);

3649 

3657 MIOPEN_EXPORT miopenStatus_t

3658 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3659  miopenFusionPlanDescriptor_t fusePlanDesc,

3660  size_t* workSpaceSize,

3661  miopenConvFwdAlgorithm_t algo);

3662 

3680 MIOPEN_EXPORT miopenStatus_t

3681 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3682  const int requestAlgoCount,

3683  int* returnedAlgoCount,

3684  miopenConvFwdAlgorithm_t* returnedAlgos);

3685 

3695 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3696  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3697 

3706 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3707  miopenFusionOpDescriptor_t* convOp,

3708  miopenConvolutionDescriptor_t convDesc,

3709  const miopenTensorDescriptor_t wDesc);

3710 

3711 //---

3712 

3713 // Activation forward create ops ---

3721 MIOPEN_EXPORT miopenStatus_t

3722 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3723  miopenFusionOpDescriptor_t* activFwdOp,

3724  miopenActivationMode_t mode);

3725 

3726 // Activation backward create ops ---

3734 MIOPEN_EXPORT miopenStatus_t

3735 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3736  miopenFusionOpDescriptor_t* activBwdOp,

3737  miopenActivationMode_t mode);

3738 

3739 // Bias create ops ---

3747 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3748  miopenFusionOpDescriptor_t* biasOp,

3749  const miopenTensorDescriptor_t bDesc);

3750 

3751 // Batch normalization create ops ---

3760 MIOPEN_EXPORT miopenStatus_t

3761 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3762  miopenFusionOpDescriptor_t* bnOp,

3763  const miopenBatchNormMode_t bn_mode,

3764  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3765 

3775 MIOPEN_EXPORT miopenStatus_t

3776 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3777  miopenFusionOpDescriptor_t* bnFwdOp,

3778  const miopenBatchNormMode_t bn_mode,

3779  bool runningMeanVariance);

3780 

3788 MIOPEN_EXPORT miopenStatus_t

3789 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3790  miopenFusionOpDescriptor_t* bnBwdOp,

3791  const miopenBatchNormMode_t bn_mode);

3792 

3793 //---

3799 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

3800 

3806 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

3807 

3808 // Convolution set arguments ---

3818 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,

3819  const miopenFusionOpDescriptor_t convOp,

3820  const void* alpha,

3821  const void* beta,

3822  const void* w);

3823 // Activation set arguments ---

3835 MIOPEN_EXPORT miopenStatus_t

3836 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,

3837  const miopenFusionOpDescriptor_t activFwdOp,

3838  const void* alpha,

3839  const void* beta,

3840  double activAlpha,

3841  double activBeta,

3842  double activGamma);

3843 

3857 MIOPEN_EXPORT miopenStatus_t

3858 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,

3859  const miopenFusionOpDescriptor_t activBwdOp,

3860  const void* alpha,

3861  const void* beta,

3862  const void* y,

3863  const void* reserved,

3864  double activAlpha,

3865  double activBeta,

3866  double activGamma);

3867 

3868 // Batch Normalization set arguments ---

3882 MIOPEN_EXPORT miopenStatus_t

3883 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,

3884  const miopenFusionOpDescriptor_t bnOp,

3885  const void* alpha,

3886  const void* beta,

3887  const void* bnScale,

3888  const void* bnBias,

3889  const void* estimatedMean,

3890  const void* estimatedVariance,

3891  double epsilon);

3892 

3909 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,

3910  const miopenFusionOpDescriptor_t bnOp,

3911  const void* alpha,

3912  const void* beta,

3913  const void* bnScale,

3914  const void* bnBias,

3915  void* savedMean,

3916  void* savedInvVariance,

3917  void* runningMean,

3918  void* runningVariance,

3919  double expAvgFactor,

3920  double epsilon);

3921 

3937 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,

3938  const miopenFusionOpDescriptor_t bnOp,

3939  const void* alpha,

3940  const void* beta,

3941  const void* x,

3942  const void* bnScale,

3943  const void* bnBias,

3944  void* resultBnScaleDiff,

3945  void* resultBnBiasDiff,

3946  const void* savedMean,

3947  const void* savedInvVariance);

3948 

3949 // Bias forward set arguments ---

3959 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,

3960  const miopenFusionOpDescriptor_t biasOp,

3961  const void* alpha,

3962  const void* beta,

3963  const void* bias);

3964 

3979 MIOPEN_EXPORT miopenStatus_t

3980 miopenExecuteFusionPlan(const miopenHandle_t handle,

3981  const miopenFusionPlanDescriptor_t fusePlanDesc,

3982  const miopenTensorDescriptor_t inputDesc,

3983  const void* input,

3984  const miopenTensorDescriptor_t outputDesc,

3985  void* output,

3986  miopenOperatorArgs_t args);

3987 

4002 MIOPEN_EXPORT miopenStatus_t

4003 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,

4004  const miopenFusionPlanDescriptor_t fusePlanDesc,

4005  const miopenTensorDescriptor_t inputDesc,

4006  const void* input,

4007  const miopenTensorDescriptor_t outputDesc,

4008  void* output,

4009  miopenOperatorArgs_t args,

4010  void* workspace,

4011  size_t workspaceSize);

4012 

4036 MIOPEN_EXPORT miopenStatus_t

4037 miopenConvolutionBiasActivationForward(miopenHandle_t handle,

4038  const void* alpha1,

4039  const miopenTensorDescriptor_t xDesc,

4040  const void* x,

4041  const miopenTensorDescriptor_t wDesc,

4042  const void* w,

4043  const miopenConvolutionDescriptor_t convDesc,

4044  miopenConvFwdAlgorithm_t algo,

4045  void* workspace,

4046  size_t workspaceSizeInBytes,

4047  const void* alpha2,

4048  const miopenTensorDescriptor_t zDesc,

4049  const void* z,

4050  const miopenTensorDescriptor_t biasDesc,

4051  const void* bias,

4052  const miopenActivationDescriptor_t activationDesc,

4053  const miopenTensorDescriptor_t yDesc,

4054  void* y);

4056 // CLOSEOUT FUSION DOXYGEN GROUP

4057 

4066 typedef enum

4067 {

4068  miopenRNNRELU = 0,

4069  miopenRNNTANH = 1,

4070  miopenLSTM = 2,

4071  miopenGRU = 3,

4072 } miopenRNNMode_t;

4073 

4077 typedef enum

4078 {

4079  miopenRNNlinear = 0,

4080  miopenRNNskip = 1,

4081 } miopenRNNInputMode_t;

4082 

4086 typedef enum

4087 {

4088  miopenRNNdefault = 0,

4090  miopenRNNfundamental = 1,

4092  miopenRNNroundedDynamic = 2,

4094 } miopenRNNAlgo_t;

4095 

4099 typedef enum

4100 {

4101  miopenRNNunidirection = 0,

4102  miopenRNNbidirection = 1,

4103 } miopenRNNDirectionMode_t;

4104 

4108 typedef enum

4109 {

4110  miopenRNNNoBias = 0,

4111  miopenRNNwithBias = 1,

4112 } miopenRNNBiasMode_t;

4113 

4117 typedef enum

4118 {

4119  miopenRNNAlgoGEMM = 0,

4120 } miopenRNNGEMMalgoMode_t;

4121 

4125 typedef enum

4126 {

4127  miopenRNNIONotPadded = 0,

4128  miopenRNNIOWithPadding = 1,

4129 } miopenRNNPaddingMode_t;

4130 

4134 typedef enum

4135 {

4136  miopenRNNTraining = 0,

4137  miopenRNNInference = 1,

4138 } miopenRNNFWDMode_t;

4139 

4143 typedef enum

4144 {

4145  miopenRNNDataUnknownLayout = 0,

4146  miopenRNNDataSeqMajorNotPadded = 1,

4147  miopenRNNDataSeqMajorPadded = 2,

4148  miopenRNNDataBatchMajorPadded = 3,

4149 } miopenRNNBaseLayout_t;

4150 

4157 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

4158 

4171 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4172  miopenRNNMode_t* rnnMode,

4173  miopenRNNAlgo_t* algoMode,

4174  miopenRNNInputMode_t* inputMode,

4175  miopenRNNDirectionMode_t* dirMode,

4176  miopenRNNBiasMode_t* biasMode,

4177  int* hiddenSize,

4178  int* layer);

4179 

4196 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4197  int* hiddenSize,

4198  int* layer,

4199  miopenDropoutDescriptor_t* dropoutDesc,

4200  miopenRNNInputMode_t* inputMode,

4201  miopenRNNDirectionMode_t* dirMode,

4202  miopenRNNMode_t* rnnMode,

4203  miopenRNNBiasMode_t* biasMode,

4204  miopenRNNAlgo_t* algoMode,

4205  miopenDataType_t* dataType);

4206 

4212 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

4213 

4229 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4230  const int hsize,

4231  const int nlayers,

4232  miopenRNNInputMode_t inMode,

4233  miopenRNNDirectionMode_t direction,

4234  miopenRNNMode_t rnnMode,

4235  miopenRNNBiasMode_t biasMode,

4236  miopenRNNAlgo_t algo,

4237  miopenDataType_t dataType);

4238 

4257 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4258  const int hsize,

4259  const int nlayers,

4260  miopenDropoutDescriptor_t dropoutDesc,

4261  miopenRNNInputMode_t inMode,

4262  miopenRNNDirectionMode_t direction,

4263  miopenRNNMode_t rnnMode,

4264  miopenRNNBiasMode_t biasMode,

4265  miopenRNNAlgo_t algo,

4266  miopenDataType_t dataType);

4267 

4282 MIOPEN_EXPORT miopenStatus_t

4283 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4284  miopenDataType_t dataType,

4285  miopenRNNBaseLayout_t layout,

4286  int maxSequenceLen,

4287  int batchSize,

4288  int vectorSize,

4289  const int* sequenceLenArray,

4290  void* paddingMarker);

4291 

4310 MIOPEN_EXPORT miopenStatus_t

4311 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4312  miopenDataType_t* dataType,

4313  miopenRNNBaseLayout_t* layout,

4314  int* maxSequenceLen,

4315  int* batchSize,

4316  int* vectorSize,

4317  int sequenceLenArrayLimit,

4318  int* sequenceLenArray,

4319  void* paddingMarker);

4320 

4337 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,

4338  const miopenRNNDescriptor_t rnnDesc,

4339  const int sequenceLen,

4340  const miopenTensorDescriptor_t* xDesc,

4341  size_t* numBytes);

4342 

4359 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,

4360  miopenRNNDescriptor_t rnnDesc,

4361  const int sequenceLen,

4362  const miopenTensorDescriptor_t* xDesc,

4363  size_t* numBytes);

4364 

4381 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,

4382  miopenRNNDescriptor_t rnnDesc,

4383  miopenSeqTensorDescriptor_t xDesc,

4384  miopenRNNFWDMode_t fwdMode,

4385  size_t* workSpaceSize,

4386  size_t* reserveSpaceSize);

4387 

4400 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

4401  miopenRNNDescriptor_t rnnDesc,

4402  miopenTensorDescriptor_t xDesc,

4403  size_t* numBytes,

4404  miopenDataType_t dtype);

4405 

4418 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

4419  miopenRNNDescriptor_t rnnDesc,

4420  miopenTensorDescriptor_t xDesc,

4421  miopenTensorDescriptor_t wDesc,

4422  miopenDataType_t dtype);

4423 

4441 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

4442  miopenRNNDescriptor_t rnnDesc,

4443  const int seqLen,

4444  miopenTensorDescriptor_t* xDesc,

4445  size_t* numBytes);

4446 

4459 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

4460  miopenRNNDescriptor_t rnnDesc,

4461  const int seqLen,

4462  miopenTensorDescriptor_t* xDesc,

4463  size_t* numBytes);

4464 

4505 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,

4506  miopenRNNDescriptor_t rnnDesc,

4507  const int layer,

4508  miopenTensorDescriptor_t xDesc,

4509  const int paramID,

4510  size_t* numBytes);

4511 

4549 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

4550  miopenRNNDescriptor_t rnnDesc,

4551  const int layer,

4552  const int biasID,

4553  size_t* numBytes);

4554 

4613 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,

4614  miopenRNNDescriptor_t rnnDesc,

4615  const int layer,

4616  miopenTensorDescriptor_t xDesc,

4617  miopenTensorDescriptor_t wDesc,

4618  const void* w,

4619  const int paramID,

4620  miopenTensorDescriptor_t paramDesc,

4621  void* layerParam);

4622 

4680 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,

4681  miopenRNNDescriptor_t rnnDesc,

4682  const int layer,

4683  miopenTensorDescriptor_t xDesc,

4684  miopenTensorDescriptor_t wDesc,

4685  const void* w,

4686  const int biasID,

4687  miopenTensorDescriptor_t biasDesc,

4688  void* layerBias);

4689 

4744 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,

4745  const int layer,

4746  miopenTensorDescriptor_t xDesc,

4747  const int paramID,

4748  miopenTensorDescriptor_t paramDesc,

4749  size_t* layerParamOffset);

4750 

4801 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,

4802  const int layer,

4803  miopenTensorDescriptor_t xDesc,

4804  const int biasID,

4805  miopenTensorDescriptor_t biasDesc,

4806  size_t* layerBiasOffset);

4807 

4860 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,

4861  miopenRNNDescriptor_t rnnDesc,

4862  const int layer,

4863  miopenTensorDescriptor_t xDesc,

4864  miopenTensorDescriptor_t wDesc,

4865  void* w,

4866  const int paramID,

4867  miopenTensorDescriptor_t paramDesc,

4868  const void* layerParam);

4869 

4920 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,

4921  miopenRNNDescriptor_t rnnDesc,

4922  const int layer,

4923  miopenTensorDescriptor_t xDesc,

4924  miopenTensorDescriptor_t wDesc,

4925  void* w,

4926  const int biasID,

4927  miopenTensorDescriptor_t biasDesc,

4928  const void* layerBias);

4929 

4941 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4942  miopenRNNPaddingMode_t paddingMode);

4943 

4951 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

4952  miopenRNNPaddingMode_t* paddingMode);

4953 

5004 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,

5005  const miopenRNNDescriptor_t rnnDesc,

5006  miopenRNNFWDMode_t fwdMode,

5007  const miopenSeqTensorDescriptor_t xDesc,

5008  const void* x,

5009  const miopenTensorDescriptor_t hDesc,

5010  const void* hx,

5011  void* hy,

5012  const miopenTensorDescriptor_t cDesc,

5013  const void* cx,

5014  void* cy,

5015  const miopenSeqTensorDescriptor_t yDesc,

5016  void* y,

5017  const void* w,

5018  size_t weightSpaceSize,

5019  void* workSpace,

5020  size_t workSpaceNumBytes,

5021  void* reserveSpace,

5022  size_t reserveSpaceNumBytes);

5023 

5073 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,

5074  const miopenRNNDescriptor_t rnnDesc,

5075  const miopenSeqTensorDescriptor_t yDesc,

5076  const void* y,

5077  const void* dy,

5078  const miopenTensorDescriptor_t hDesc,

5079  const void* hx,

5080  const void* dhy,

5081  void* dhx,

5082  const miopenTensorDescriptor_t cDesc,

5083  const void* cx,

5084  const void* dcy,

5085  void* dcx,

5086  const miopenSeqTensorDescriptor_t xDesc,

5087  void* dx,

5088  const void* w,

5089  size_t weightSpaceSize,

5090  void* workSpace,

5091  size_t workSpaceNumBytes,

5092  void* reserveSpace,

5093  size_t reserveSpaceNumBytes);

5094 

5128 MIOPEN_EXPORT miopenStatus_t

5129 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,

5130  const miopenRNNDescriptor_t rnnDesc,

5131  const miopenSeqTensorDescriptor_t xDesc,

5132  const void* x,

5133  const miopenTensorDescriptor_t hDesc,

5134  const void* hx,

5135  const miopenSeqTensorDescriptor_t yDesc,

5136  const void* y,

5137  void* dw,

5138  size_t weightSpaceSize,

5139  void* workSpace,

5140  size_t workSpaceNumBytes,

5141  const void* reserveSpace,

5142  size_t reserveSpaceNumBytes);

5143 

5201 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,

5202  const miopenRNNDescriptor_t rnnDesc,

5203  const int sequenceLen,

5204  const miopenTensorDescriptor_t* xDesc,

5205  const void* x,

5206  const miopenTensorDescriptor_t hxDesc,

5207  const void* hx,

5208  const miopenTensorDescriptor_t cxDesc,

5209  const void* cx,

5210  const miopenTensorDescriptor_t wDesc,

5211  const void* w,

5212  const miopenTensorDescriptor_t* yDesc,

5213  void* y,

5214  const miopenTensorDescriptor_t hyDesc,

5215  void* hy,

5216  const miopenTensorDescriptor_t cyDesc,

5217  void* cy,

5218  void* workSpace,

5219  size_t workSpaceNumBytes,

5220  void* reserveSpace,

5221  size_t reserveSpaceNumBytes);

5222 

5295 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,

5296  const miopenRNNDescriptor_t rnnDesc,

5297  const int sequenceLen,

5298  const miopenTensorDescriptor_t* yDesc,

5299  const void* y,

5300  const miopenTensorDescriptor_t* dyDesc,

5301  const void* dy,

5302  const miopenTensorDescriptor_t dhyDesc,

5303  const void* dhy,

5304  const miopenTensorDescriptor_t dcyDesc,

5305  const void* dcy,

5306  const miopenTensorDescriptor_t wDesc,

5307  const void* w,

5308  const miopenTensorDescriptor_t hxDesc,

5309  const void* hx,

5310  const miopenTensorDescriptor_t cxDesc,

5311  const void* cx,

5312  const miopenTensorDescriptor_t* dxDesc,

5313  void* dx,

5314  const miopenTensorDescriptor_t dhxDesc,

5315  void* dhx,

5316  const miopenTensorDescriptor_t dcxDesc,

5317  void* dcx,

5318  void* workSpace,

5319  size_t workSpaceNumBytes,

5320  void* reserveSpace,

5321  size_t reserveSpaceNumBytes);

5322 

5359 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,

5360  const miopenRNNDescriptor_t rnnDesc,

5361  const int sequenceLen,

5362  const miopenTensorDescriptor_t* xDesc,

5363  const void* x,

5364  const miopenTensorDescriptor_t hxDesc,

5365  const void* hx,

5366  const miopenTensorDescriptor_t* yDesc,

5367  const void* y,

5368  const miopenTensorDescriptor_t dwDesc,

5369  void* dw,

5370  void* workSpace,

5371  size_t workSpaceNumBytes,

5372  const void* reserveSpace,

5373  size_t reserveSpaceNumBytes);

5374 

5430 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,

5431  miopenRNNDescriptor_t rnnDesc,

5432  const int sequenceLen,

5433  const miopenTensorDescriptor_t* xDesc,

5434  const void* x,

5435  const miopenTensorDescriptor_t hxDesc,

5436  const void* hx,

5437  const miopenTensorDescriptor_t cxDesc,

5438  const void* cx,

5439  const miopenTensorDescriptor_t wDesc,

5440  const void* w,

5441  const miopenTensorDescriptor_t* yDesc,

5442  void* y,

5443  const miopenTensorDescriptor_t hyDesc,

5444  void* hy,

5445  const miopenTensorDescriptor_t cyDesc,

5446  void* cy,

5447  void* workSpace,

5448  size_t workSpaceNumBytes);

5449 

5451 // CLOSEOUT RNN DOXYGEN GROUP

5452 

5461 typedef enum

5462 {

5463  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

5464 } miopenCTCLossAlgo_t;

5465 

5472 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

5473 

5483 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5484  miopenDataType_t* dataType,

5485  int* blank_label_id,

5486  bool* apply_softmax_layer);

5487 

5493 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

5494 

5504 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5505  miopenDataType_t dataType,

5506  const int blank_label_id,

5507  bool apply_softmax_layer);

5508 

5525 MIOPEN_EXPORT miopenStatus_t

5526 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,

5527  const miopenTensorDescriptor_t probsDesc,

5528  const miopenTensorDescriptor_t gradientsDesc,

5529  const int* labels,

5530  const int* labelLengths,

5531  const int* inputLengths,

5532  miopenCTCLossAlgo_t algo,

5533  const miopenCTCLossDescriptor_t ctcLossDesc,

5534  size_t* workSpaceSize);

5535 

5555 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,

5556  const miopenTensorDescriptor_t probsDesc,

5557  const void* probs,

5558  const int* labels,

5559  const int* labelLengths,

5560  const int* inputLengths,

5561  void* losses,

5562  const miopenTensorDescriptor_t gradientsDesc,

5563  void* gradients,

5564  miopenCTCLossAlgo_t algo,

5565  const miopenCTCLossDescriptor_t ctcLossDesc,

5566  void* workSpace,

5567  size_t workSpaceSize);

5568 

5570 // CLOSEOUT LossFunction DOXYGEN GROUP

5571 

5572 // Dropout APIs

5581 typedef enum

5582 {

5583  MIOPEN_RNG_PSEUDO_XORWOW = 0,

5584 } miopenRNGType_t;

5585 

5591 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5592 

5598 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5599 

5608 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5609  size_t* reserveSpaceSizeInBytes);

5610 

5619 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5620  size_t* stateSizeInBytes);

5621 

5638 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5639  miopenHandle_t handle,

5640  float* dropout,

5641  void** states,

5642  unsigned long long* seed,

5643  bool* use_mask,

5644  bool* state_evo,

5645  miopenRNGType_t* rng_mode);

5646 

5669 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5670  miopenHandle_t handle,

5671  float dropout,

5672  void* states,

5673  size_t stateSizeInBytes,

5674  unsigned long long seed,

5675  bool use_mask,

5676  bool state_evo,

5677  miopenRNGType_t rng_mode);

5678 

5698 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5699  miopenHandle_t handle,

5700  float dropout,

5701  void* states,

5702  size_t stateSizeInBytes,

5703  unsigned long long seed,

5704  bool use_mask,

5705  bool state_evo,

5706  miopenRNGType_t rng_mode);

5707 

5725 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,

5726  const miopenDropoutDescriptor_t dropoutDesc,

5727  const miopenTensorDescriptor_t noise_shape,

5728  const miopenTensorDescriptor_t xDesc,

5729  const void* x,

5730  const miopenTensorDescriptor_t yDesc,

5731  void* y,

5732  void* reserveSpace,

5733  size_t reserveSpaceSizeInBytes);

5734 

5752 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,

5753  const miopenDropoutDescriptor_t dropoutDesc,

5754  const miopenTensorDescriptor_t noise_shape,

5755  const miopenTensorDescriptor_t dyDesc,

5756  const void* dy,

5757  const miopenTensorDescriptor_t dxDesc,

5758  void* dx,

5759  void* reserveSpace,

5760  size_t reserveSpaceSizeInBytes);

5761 

5763 // CLOSEOUT DROPOUT DOXYGEN GROUP

5764 

5765 // TensorReduce APIs

5776 MIOPEN_EXPORT miopenStatus_t

5777 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5778 

5784 MIOPEN_EXPORT miopenStatus_t

5785 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5786 

5799 MIOPEN_EXPORT miopenStatus_t

5800 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

5801  miopenReduceTensorOp_t reduceTensorOp,

5802  miopenDataType_t reduceTensorCompType,

5803  miopenNanPropagation_t reduceTensorNanOpt,

5804  miopenReduceTensorIndices_t reduceTensorIndices,

5805  miopenIndicesType_t reduceTensorIndicesType);

5806 

5822 MIOPEN_EXPORT miopenStatus_t

5823 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,

5824  miopenReduceTensorOp_t* reduceTensorOp,

5825  miopenDataType_t* reduceTensorCompType,

5826  miopenNanPropagation_t* reduceTensorNanOpt,

5827  miopenReduceTensorIndices_t* reduceTensorIndices,

5828  miopenIndicesType_t* reduceTensorIndicesType);

5829 

5839 MIOPEN_EXPORT miopenStatus_t

5840 miopenGetReductionIndicesSize(miopenHandle_t handle,

5841  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5842  const miopenTensorDescriptor_t aDesc,

5843  const miopenTensorDescriptor_t cDesc,

5844  size_t* sizeInBytes);

5845 

5855 MIOPEN_EXPORT miopenStatus_t

5856 miopenGetReductionWorkspaceSize(miopenHandle_t handle,

5857  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5858  const miopenTensorDescriptor_t aDesc,

5859  const miopenTensorDescriptor_t cDesc,

5860  size_t* sizeInBytes);

5861 

5885 MIOPEN_EXPORT miopenStatus_t

5886 miopenReduceTensor(miopenHandle_t handle,

5887  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5888  void* indices,

5889  size_t indicesSizeInBytes,

5890  void* workspace,

5891  size_t workspaceSizeInBytes,

5892  const void* alpha,

5893  const miopenTensorDescriptor_t aDesc,

5894  const void* A,

5895  const void* beta,

5896  const miopenTensorDescriptor_t cDesc,

5897  void* C);

5898 

5900 // CLOSEOUT TensorReduce DOXYGEN GROUP

5901 

5902 // Find 2.0 API

5913 MIOPEN_DECLARE_OBJECT(miopenProblem);

5914 

5918 typedef enum

5919 {

5920  miopenProblemDirectionForward = 0,

5921  miopenProblemDirectionBackward = 1,

5922  miopenProblemDirectionBackwardWeights = 2,

5923 #ifdef MIOPEN_BETA_API

5924  miopenProblemDirectionInference = 4,

5925 #endif

5926 } miopenProblemDirection_t;

5927 

5931 typedef enum

5932 {

5933  miopenTensorArgumentIdInvalid = 0,

5934  miopenTensorConvolutionX = 1,

5935  miopenTensorConvolutionW = 2,

5936  miopenTensorConvolutionY = 3,

5937 

5938  miopenTensorMhaK = 4,

5939  miopenTensorMhaQ = 5,

5940  miopenTensorMhaV = 6,

5941  miopenTensorMhaDescaleK = 7,

5942  miopenTensorMhaDescaleQ = 8,

5943  miopenTensorMhaDescaleV = 9,

5944  miopenTensorMhaDescaleS = 10,

5945  miopenTensorMhaScaleS = 11,

5946  miopenTensorMhaScaleO = 12,

5947  miopenTensorMhaDropoutProbability = 13,

5948  miopenTensorMhaDropoutSeed = 14,

5949  miopenTensorMhaDropoutOffset = 15,

5950  miopenTensorMhaO = 16,

5951  miopenTensorMhaAmaxO = 17,

5952  miopenTensorMhaAmaxS = 18,

5953  miopenTensorMhaM = 19,

5954  miopenTensorMhaZInv = 20,

5955  miopenTensorMhaDO = 21,

5956  miopenTensorMhaDescaleO = 22,

5957  miopenTensorMhaDescaleDO = 23,

5958  miopenTensorMhaDescaleDS = 24,

5959  miopenTensorMhaScaleDS = 25,

5960  miopenTensorMhaScaleDQ = 26,

5961  miopenTensorMhaScaleDK = 27,

5962  miopenTensorMhaScaleDV = 28,

5963  miopenTensorMhaDQ = 29,

5964  miopenTensorMhaDK = 30,

5965  miopenTensorMhaDV = 31,

5966  miopenTensorMhaAmaxDQ = 32,

5967  miopenTensorMhaAmaxDK = 33,

5968  miopenTensorMhaAmaxDV = 34,

5969  miopenTensorMhaAmaxDS = 35,

5970  miopenTensorMhaBias = 36,

5971 

5972 #ifdef MIOPEN_BETA_API

5973  miopenTensorActivationX = 37,

5974  miopenTensorActivationY = 38,

5975  miopenTensorActivationDX = 39,

5976  miopenTensorActivationDY = 40,

5977  miopenTensorBiasX = 41,

5978  miopenTensorBiasY = 42,

5979  miopenTensorBias = 43,

5980  miopenTensorSoftmaxX = 44,

5981  miopenTensorSoftmaxY = 45,

5982  miopenTensorSoftmaxDX = 46,

5983  miopenTensorSoftmaxDY = 47,

5984  miopenTensorBatchnormX = 48,

5985  miopenTensorBatchnormY = 49,

5986  miopenTensorBatchnormRunningMean = 50,

5987  miopenTensorBatchnormRunningVariance = 51,

5988  miopenTensorBatchnormSavedMean = 52,

5989  miopenTensorBatchnormSavedVariance = 53,

5990  miopenTensorBatchnormScale = 54,

5991  miopenTensorBatchnormScaleDiff = 55,

5992  miopenTensorBatchnormEstimatedMean = 56,

5993  miopenTensorBatchnormEstimatedVariance = 57,

5994  miopenTensorBatchnormBias = 58,

5995  miopenTensorBatchnormBiasDiff = 59,

5996  miopenTensorBatchnormDX = 60,

5997  miopenTensorBatchnormDY = 61,

5998 #endif

5999 

6000  miopenTensorArgumentIsScalar = 1U << 31,

6001 

6002  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,

6003 #ifdef MIOPEN_BETA_API

6004  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,

6005  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,

6006 #endif

6007 } miopenTensorArgumentId_t;

6008 

6012 typedef enum

6013 {

6014  miopenFindResultsOrderByTime = 0,

6015  miopenFindResultsOrderByWorkspaceSize = 1,

6016 } miopenFindResultsOrder_t;

6017 

6025 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

6026  miopenConvolutionDescriptor_t operatorDesc,

6027  miopenProblemDirection_t direction);

6028 

6040 typedef enum

6041 {

6042  miopenMhaMaskNone = 0,

6043  miopenMhaMaskCausal = 1,

6044 } miopenMhaMask_t;

6045 

6046 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

6047  miopenMhaDescriptor_t operatorDesc,

6048  miopenProblemDirection_t direction);

6049 

6056 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

6057 

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

6068 

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

6079 

6086 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

6087 

6099 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

6100  float alpha,

6101  float beta,

6102  miopenSoftmaxAlgorithm_t algorithm,

6103  miopenSoftmaxMode_t mode);

6104 

6116 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

6117  float* alpha,

6118  float* beta,

6119  miopenSoftmaxAlgorithm_t* algorithm,

6120  miopenSoftmaxMode_t* mode);

6121 

6127 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

6128 

6136 MIOPEN_EXPORT miopenStatus_t

6137 miopenSetProblemTensorDescriptor(miopenProblem_t problem,

6138  miopenTensorArgumentId_t id,

6139  const miopenTensorDescriptor_t descriptor);

6140 

6143 MIOPEN_DECLARE_OBJECT(miopenFindOptions);

6144 

6150 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

6151 

6157 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

6158 

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

6166 

6173 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

6174  miopenFindResultsOrder_t value);

6175 

6183 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

6184  size_t value);

6185 

6193 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

6194  void* buffer,

6195  size_t size);

6196 

6205 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

6206  miopenTensorArgumentId_t id,

6207  void* buffer);

6208 

6216 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,

6217  unsigned attach);

6218 

6221 MIOPEN_DECLARE_OBJECT(miopenSolution);

6222 

6234 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,

6235  miopenProblem_t problem,

6236  miopenFindOptions_t options,

6237  miopenSolution_t* solutions,

6238  size_t* numSolutions,

6239  size_t maxSolutions);

6240 

6243 struct miopenTensorArgument_t

6244 {

6245  /* @brief Identifier of the tensor argument.

6246  */

6247  miopenTensorArgumentId_t id;

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

6249  *

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

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

6252  */

6253  miopenTensorDescriptor_t* descriptor;

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

6255  * the value is scalar.

6256  */

6257  void* buffer;

6258 };

6259 

6271 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,

6272  miopenSolution_t solution,

6273  size_t nInputs,

6274  const miopenTensorArgument_t* tensors,

6275  void* workspace,

6276  size_t workspaceSize);

6277 

6283 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

6284 

6292 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

6293  const char* data,

6294  size_t size);

6295 

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

6303 

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

6311 

6318 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

6319  size_t* workspaceSize);

6320 

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

6328 

6335 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

6336  uint64_t* solverId);

6337 

6344 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

6345  miopenConvAlgorithm_t* result);

6346 

6347 #ifdef MIOPEN_BETA_API

6348 

6357 MIOPEN_EXPORT miopenStatus_t

6358 miopenCreateActivationProblem(miopenProblem_t* problem,

6359  miopenActivationDescriptor_t operatorDesc,

6360  miopenProblemDirection_t direction);

6361 

6370 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

6371  miopenBatchNormMode_t mode,

6372  bool runningMeanVariance,

6373  miopenProblemDirection_t direction);

6374 

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

6395 

6403 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

6404  miopenProblemDirection_t direction);

6405 

6414 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,

6415  miopenSoftmaxDescriptor_t operatorDesc,

6416  miopenProblemDirection_t direction);

6417 

6418 #endif

6419 

6421 // CLOSEOUT find2 DOXYGEN GROUP

6422 

6423 #ifdef MIOPEN_BETA_API

6424 

6429 typedef enum

6430 {

6431  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,

6432  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =

6433  1,

6434 } miopenReduceCalculationNanPropagation_t;

6435 

6436 // ReduceCalculation APIs

6445 typedef enum

6446 {

6447  MIOPEN_REDUCE_CALCULATION_PROD =

6448  1,

6449  MIOPEN_REDUCE_CALCULATION_SUM =

6450  2,

6451 } miopenReduceCalculationOp_t;

6452 

6462 MIOPEN_EXPORT miopenStatus_t

6463 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,

6464  const miopenTensorDescriptor_t xDesc,

6465  const int32_t dim,

6466  const miopenReduceCalculationOp_t reduceCalculationOp,

6467  const miopenTensorDescriptor_t reduceDesc,

6468  size_t* sizeInBytes);

6469 

6483 MIOPEN_EXPORT miopenStatus_t

6484 miopenReduceCalculationForward(miopenHandle_t handle,

6485  miopenReduceCalculationNanPropagation_t nanPropagation,

6486  void* workspace,

6487  size_t workspaceSizeInBytes,

6488  const miopenTensorDescriptor_t xDesc,

6489  const void* x,

6490  const int32_t dim,

6491  const miopenReduceCalculationOp_t reduceCalculationOp,

6492  const miopenTensorDescriptor_t reduceDesc,

6493  void* y);

6494 

6496 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP

6497 #endif // MIOPEN_BETA_API

6498 

6499 #ifdef MIOPEN_BETA_API

6500 

6505 typedef enum

6506 {

6507  MIOPEN_REDUCE_EXTREME_ARGMIN =

6508  1,

6509  MIOPEN_REDUCE_EXTREME_ARGMAX =

6510  2,

6511  MIOPEN_REDUCE_EXTREME_MIN =

6512  3,

6513  MIOPEN_REDUCE_EXTREME_MAX =

6514  4,

6515 } miopenReduceExtremeOp_t;

6516 

6517 // ReduceExtreme APIs

6537 MIOPEN_EXPORT miopenStatus_t

6538 miopenReduceExtremeForward(miopenHandle_t handle,

6539  const miopenTensorDescriptor_t xDesc,

6540  const void* x,

6541  const int32_t dim,

6542  const miopenReduceExtremeOp_t reduceExtremeOp,

6543  const miopenTensorDescriptor_t yDesc,

6544  void* y,

6545  const miopenTensorDescriptor_t indiceDesc,

6546  void* indice);

6547 

6549 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP

6550 #endif // MIOPEN_BETA_API

6551 

6552 #ifdef MIOPEN_BETA_API

6553 // GroupNorm APIs

6578 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,

6579  miopenNormMode_t mode,

6580  const miopenTensorDescriptor_t xDesc,

6581  const void* x,

6582  const miopenTensorDescriptor_t weightDesc,

6583  const void* weight,

6584  const miopenTensorDescriptor_t biasDesc,

6585  const void* bias,

6586  const uint64_t num_groups,

6587  const float epsilon,

6588  const miopenTensorDescriptor_t yDesc,

6589  void* y,

6590  const miopenTensorDescriptor_t meanDesc,

6591  void* mean,

6592  const miopenTensorDescriptor_t rstdDesc,

6593  void* rstd);

6594 

6596 // CLOSEOUT groupnorm DOXYGEN GROUP

6597 #endif // MIOPEN_BETA_API

6598 

6599 #ifdef MIOPEN_BETA_API

6600 // LayerNorm APIs

6627 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,

6628  miopenNormMode_t mode,

6629  const miopenTensorDescriptor_t xDesc,

6630  const void* x,

6631  const miopenTensorDescriptor_t x2Desc,

6632  const void* x2,

6633  const miopenTensorDescriptor_t weightDesc,

6634  const void* weight,

6635  const miopenTensorDescriptor_t biasDesc,

6636  const void* bias,

6637  const float epsilon,

6638  const int32_t normalized_dim,

6639  const miopenTensorDescriptor_t yDesc,

6640  void* y,

6641  const miopenTensorDescriptor_t meanDesc,

6642  void* mean,

6643  const miopenTensorDescriptor_t rstdDesc,

6644  void* rstd);

6645 

6647 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6648 #endif // MIOPEN_BETA_API

6649 

6650 #ifdef MIOPEN_BETA_API

6651 // LayerNorm APIs

6671 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,

6672  miopenNormMode_t mode,

6673  const miopenTensorDescriptor_t xDesc,

6674  const void* x,

6675  const miopenTensorDescriptor_t weightDesc,

6676  const void* weight,

6677  const float epsilon,

6678  const miopenTensorDescriptor_t yDesc,

6679  void* y,

6680  const miopenTensorDescriptor_t rstdDesc,

6681  void* rstd);

6682 

6697 MIOPEN_EXPORT miopenStatus_t

6698 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,

6699  miopenNormMode_t mode,

6700  const miopenTensorDescriptor_t dyDesc,

6701  const miopenTensorDescriptor_t xDesc,

6702  const miopenTensorDescriptor_t weightDesc,

6703  const miopenTensorDescriptor_t rstdDesc,

6704  const miopenTensorDescriptor_t dxDesc,

6705  const miopenTensorDescriptor_t dwDesc,

6706  size_t* sizeInBytes);

6707 

6728 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,

6729  miopenNormMode_t mode,

6730  void* workspace,

6731  size_t workspaceSizeInBytes,

6732  const miopenTensorDescriptor_t dyDesc,

6733  const void* dy,

6734  const miopenTensorDescriptor_t xDesc,

6735  const void* x,

6736  const miopenTensorDescriptor_t weightDesc,

6737  const void* weight,

6738  const miopenTensorDescriptor_t rstdDesc,

6739  const void* rstd,

6740  const miopenTensorDescriptor_t dxDesc,

6741  void* dx,

6742  const miopenTensorDescriptor_t dwDesc,

6743  void* dw);

6745 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6746 #endif // MIOPEN_BETA_API

6747 

6748 #ifdef MIOPEN_BETA_API

6749 // Graph API

6761 typedef enum

6762 {

6763  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,

6764  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,

6765  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,

6766  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,

6767  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,

6768  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,

6769  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,

6770  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,

6771  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,

6772  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,

6773  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,

6774  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,

6775  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,

6776  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,

6777  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,

6778  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,

6779  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,

6780  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,

6781  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,

6782  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,

6783  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,

6784  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,

6785  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,

6786  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,

6787  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,

6788  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,

6789  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,

6790  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,

6791  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,

6792  MIOPEN_BACKEND_RNG_DESCRIPTOR,

6793  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,

6794  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,

6795 } miopenBackendDescriptorType_t;

6796 

6804 typedef enum

6805 {

6806  MIOPEN_ATTR_POINTWISE_MODE = 0,

6807  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,

6808  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,

6809  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,

6810  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,

6811  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,

6812  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,

6813  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,

6814  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,

6815  MIOPEN_ATTR_POINTWISE_AXIS = 9,

6816 

6817  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,

6818  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,

6819  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,

6820  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,

6821  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,

6822  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,

6823  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,

6824 

6825  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,

6826  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,

6827  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,

6828  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,

6829 

6830  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,

6831  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,

6832  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,

6833 

6834  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,

6835  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,

6836  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,

6837  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,

6838  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,

6839  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,

6840 

6841  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,

6842  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,

6843  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,

6844  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,

6845 

6846  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,

6847  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,

6848 

6849  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,

6850  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,

6851  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,

6852  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,

6853  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,

6854  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,

6855  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,

6856  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,

6857  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,

6858  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,

6859  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,

6860  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,

6861  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,

6862  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,

6863  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,

6864  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,

6865  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,

6866  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,

6867  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,

6868  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,

6869  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,

6870  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,

6871  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,

6872  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,

6873  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,

6874  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,

6875  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,

6876 

6877  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,

6878  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,

6879  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,

6880  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,

6881  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,

6882 

6883  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,

6884  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,

6885  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,

6886  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,

6887  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,

6888  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,

6889  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,

6890  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,

6891  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,

6892  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,

6893  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,

6894  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,

6895  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,

6896  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,

6897  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,

6898  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,

6899  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,

6900 

6901  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,

6902  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,

6903  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,

6904 

6905  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,

6906  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,

6907  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,

6908  MIOPEN_ATTR_TENSOR_STRIDES = 903,

6909  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,

6910  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,

6911  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,

6912  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,

6913  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,

6914  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,

6915  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,

6916 

6917  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,

6918  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,

6919  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,

6920  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,

6921 

6922  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,

6923  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,

6924 

6925  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,

6926  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,

6927  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,

6928  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,

6929 

6930  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,

6931  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,

6932  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,

6933  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,

6934  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,

6935  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,

6936  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,

6937 

6938  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,

6939  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,

6940 

6941  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,

6942  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,

6943  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,

6944  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,

6945  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,

6946  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,

6947  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,

6948  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,

6949 

6950  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,

6951  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,

6952 

6953  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,

6954  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,

6955  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,

6956 

6957  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,

6958  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,

6959  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,

6960  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,

6961  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,

6962  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,

6963  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,

6964  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,

6965  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,

6966  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,

6967  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,

6968 

6969  MIOPEN_ATTR_RESAMPLE_MODE = 1700,

6970  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,

6971  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,

6972  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,

6973  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,

6974  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,

6975  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,

6976  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,

6977  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,

6978 

6979  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,

6980  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,

6981  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,

6982  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,

6983  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,

6984  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,

6985 

6986  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,

6987  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,

6988  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,

6989  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,

6990  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,

6991  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,

6992  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,

6993  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,

6994 

6995  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,

6996  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,

6997  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,

6998  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,

6999 

7000  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,

7001  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,

7002  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,

7003  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,

7004  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,

7005 

7006  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,

7007  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,

7008  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,

7009  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,

7010  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,

7011  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,

7012  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,

7013  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,

7014  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,

7015  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,

7016  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,

7017  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,

7018  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,

7019  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,

7020  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,

7021 

7022  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,

7023  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,

7024  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,

7025  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,

7026  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,

7027  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,

7028  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,

7029  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,

7030  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,

7031  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,

7032  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,

7033 

7034  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,

7035  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,

7036 

7037  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,

7038  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,

7039  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,

7040  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,

7041  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,

7042  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,

7043 

7044  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,

7045  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,

7046  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,

7047  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,

7048 

7049 } miopenBackendAttributeName_t;

7050 

7058 typedef enum

7059 {

7060  MIOPEN_TYPE_HANDLE = 0,

7061  MIOPEN_TYPE_DATA_TYPE,

7062  MIOPEN_TYPE_BOOLEAN,

7063  MIOPEN_TYPE_INT64,

7064  MIOPEN_TYPE_FLOAT,

7065  MIOPEN_TYPE_DOUBLE,

7066  MIOPEN_TYPE_VOID_PTR,

7067  MIOPEN_TYPE_CONVOLUTION_MODE,

7068  MIOPEN_TYPE_HEUR_MODE,

7069  MIOPEN_TYPE_KNOB_TYPE,

7070  MIOPEN_TYPE_NAN_PROPOGATION,

7071  MIOPEN_TYPE_NUMERICAL_NOTE,

7072  MIOPEN_TYPE_LAYOUT_TYPE,

7073  MIOPEN_TYPE_ATTRIB_NAME,

7074  MIOPEN_TYPE_POINTWISE_MODE,

7075  MIOPEN_TYPE_BACKEND_DESCRIPTOR,

7076  MIOPEN_TYPE_GENSTATS_MODE,

7077  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,

7078  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,

7079  MIOPEN_TYPE_BEHAVIOR_NOTE,

7080  MIOPEN_TYPE_TENSOR_REORDERING_MODE,

7081  MIOPEN_TYPE_RESAMPLE_MODE,

7082  MIOPEN_TYPE_PADDING_MODE,

7083  MIOPEN_TYPE_INT32,

7084  MIOPEN_TYPE_CHAR,

7085  MIOPEN_TYPE_SIGNAL_MODE,

7086  MIOPEN_TYPE_FRACTION,

7087  MIOPEN_TYPE_NORM_MODE,

7088  MIOPEN_TYPE_NORM_FWD_PHASE,

7089  MIOPEN_TYPE_RNG_DISTRIBUTION

7090 } miopenBackendAttributeType_t;

7091 

7097 typedef enum

7098 {

7100  MIOPEN_POINTWISE_ADD,

7101 

7104  MIOPEN_POINTWISE_ADD_SQUARE,

7105 

7107  MIOPEN_POINTWISE_DIV,

7108 

7110  MIOPEN_POINTWISE_MAX,

7111 

7113  MIOPEN_POINTWISE_MIN,

7114 

7117  MIOPEN_POINTWISE_MOD,

7118 

7120  MIOPEN_POINTWISE_MUL,

7121 

7123  MIOPEN_POINTWISE_POW,

7124 

7126  MIOPEN_POINTWISE_SUB,

7127 

7129  MIOPEN_POINTWISE_ABS,

7130 

7132  MIOPEN_POINTWISE_CEIL,

7133 

7135  MIOPEN_POINTWISE_COS,

7136 

7138  MIOPEN_POINTWISE_EXP,

7139 

7141  MIOPEN_POINTWISE_FLOOR,

7142 

7144  MIOPEN_POINTWISE_LOG,

7145 

7147  MIOPEN_POINTWISE_NEG,

7148 

7150  MIOPEN_POINTWISE_RSQRT,

7151 

7153  MIOPEN_POINTWISE_SIN,

7154 

7156  MIOPEN_POINTWISE_SQRT,

7157 

7159  MIOPEN_POINTWISE_TAN,

7160 

7162  MIOPEN_POINTWISE_ERF,

7163 

7167  MIOPEN_POINTWISE_IDENTITY,

7168 

7170  MIOPEN_POINTWISE_RELU_FWD,

7171 

7173  MIOPEN_POINTWISE_TANH_FWD,

7174 

7176  MIOPEN_POINTWISE_SIGMOID_FWD,

7177 

7179  MIOPEN_POINTWISE_ELU_FWD,

7180 

7183  MIOPEN_POINTWISE_GELU_FWD,

7184 

7186  MIOPEN_POINTWISE_SOFTPLUS_FWD,

7187 

7189  MIOPEN_POINTWISE_SWISH_FWD,

7190 

7194  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,

7195 

7198  MIOPEN_POINTWISE_RELU_BWD,

7199 

7201  MIOPEN_POINTWISE_TANH_BWD,

7202 

7204  MIOPEN_POINTWISE_SIGMOID_BWD,

7205 

7208  MIOPEN_POINTWISE_ELU_BWD,

7209 

7212  MIOPEN_POINTWISE_GELU_BWD,

7213 

7215  MIOPEN_POINTWISE_SOFTPLUS_BWD,

7216 

7218  MIOPEN_POINTWISE_SWISH_BWD,

7219 

7225  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,

7226 

7228  MIOPEN_POINTWISE_CMP_EQ,

7229 

7231  MIOPEN_POINTWISE_CMP_NEQ,

7232 

7234  MIOPEN_POINTWISE_CMP_GT,

7235 

7238  MIOPEN_POINTWISE_CMP_GE,

7239 

7241  MIOPEN_POINTWISE_CMP_LT,

7242 

7245  MIOPEN_POINTWISE_CMP_LE,

7246 

7248  MIOPEN_POINTWISE_LOGICAL_AND,

7249 

7251  MIOPEN_POINTWISE_LOGICAL_OR,

7252 

7254  MIOPEN_POINTWISE_LOGICAL_NOT,

7255 

7257  MIOPEN_POINTWISE_GEN_INDEX,

7258 

7261  MIOPEN_POINTWISE_BINARY_SELECT,

7262 

7265  MIOPEN_POINTWISE_RECIPROCAL

7266 } miopenPointwiseMode_t;

7267 

7273 typedef enum

7274 {

7275  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,

7276  MIOPEN_RNG_DISTRIBUTION_UNIFORM,

7277  MIOPEN_RNG_DISTRIBUTION_NORMAL,

7278 } miopenRngDistribution_t;

7279 

7280 typedef enum

7281 {

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

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

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

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

7286 

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

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

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

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

7291  But used to check for errors.*/

7292 } miopenAlphaBetaCase_t;

7297 typedef enum

7298 {

7299  MIOPEN_HEUR_MODE_INSTANT = 0,

7300  MIOPEN_HEUR_MODE_B = 1,

7301  MIOPEN_HEUR_MODE_FALLBACK = 2,

7302  MIOPEN_HEUR_MODE_A = 3,

7303  MIOPEN_HEUR_MODES_COUNT = 4,

7304 } miopenBackendHeurMode_t;

7305 

7318 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)

7319 

7320 

7333 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(

7334  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);

7335 

7365 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,

7366  miopenBackendAttributeName_t attributeName,

7367  miopenBackendAttributeType_t attributeType,

7368  int64_t elementCount,

7369  void* arrayOfElements);

7370 

7387 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);

7388 

7423 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,

7424  miopenBackendAttributeName_t attributeName,

7425  miopenBackendAttributeType_t attributeType,

7426  int64_t requestedElementCount,

7427  int64_t* elementCount,

7428  void* arrayOfElements);

7429 

7449 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,

7450  miopenBackendDescriptor_t executionPlan,

7451  miopenBackendDescriptor_t variantPack);

7452 

7469 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);

7470 

7488 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,

7489  miopenBackendDescriptorType_t descriptorType,

7490  size_t sizeInBytes);

7491 

7493 // CLOSEOUT BackendAPI DOXYGEN GROUP

7494 #endif // MIOPEN_BETA_API

7495 

7496 #ifdef MIOPEN_BETA_API

7497 // FusedAdam APIs

7640 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,

7641  const miopenTensorDescriptor_t paramDesc,

7642  void* param,

7643  const miopenTensorDescriptor_t gradDesc,

7644  const void* grad,

7645  const miopenTensorDescriptor_t expAvgDesc,

7646  void* expAvg,

7647  const miopenTensorDescriptor_t expAvgSqDesc,

7648  void* expAvgSq,

7649  const miopenTensorDescriptor_t maxExpAvgSqDesc,

7650  void* maxExpAvgSq,

7651  const miopenTensorDescriptor_t stateStepDesc,

7652  void* stateStep,

7653  const unsigned int state_step,

7654  const float lr,

7655  const float beta1,

7656  const float beta2,

7657  const float weight_decay,

7658  const float eps,

7659  const bool amsgrad,

7660  const bool maximize,

7661  const bool adamw,

7662  const miopenTensorDescriptor_t gradScaleDesc,

7663  const void* gradScale,

7664  const miopenTensorDescriptor_t foundInfDesc,

7665  const void* foundInf);

7666 

7807 MIOPEN_EXPORT miopenStatus_t

7808 miopenFusedAdamWithOutput(miopenHandle_t handle,

7809  const miopenTensorDescriptor_t paramInDesc,

7810  void* paramIn,

7811  const miopenTensorDescriptor_t paramOutDesc,

7812  void* paramOut,

7813  const miopenTensorDescriptor_t paramOutFloat16Desc,

7814  void* paramOutFloat16,

7815  const miopenTensorDescriptor_t gradInDesc,

7816  const void* gradIn,

7817  const miopenTensorDescriptor_t expAvgInDesc,

7818  void* expAvgIn,

7819  const miopenTensorDescriptor_t expAvgOutDesc,

7820  void* expAvgOut,

7821  const miopenTensorDescriptor_t expAvgSqInDesc,

7822  void* expAvgSqIn,

7823  const miopenTensorDescriptor_t expAvgSqOutDesc,

7824  void* expAvgSqOut,

7825  const miopenTensorDescriptor_t maxExpAvgSqInDesc,

7826  void* maxExpAvgSqIn,

7827  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,

7828  void* maxExpAvgSqOut,

7829  const miopenTensorDescriptor_t stateStepInDesc,

7830  void* stateStepIn,

7831  const miopenTensorDescriptor_t stateStepOutDesc,

7832  void* stateStepOut,

7833  const unsigned int state_step,

7834  const float lr,

7835  const float beta1,

7836  const float beta2,

7837  const float weight_decay,

7838  const float eps,

7839  const bool amsgrad,

7840  const bool maximize,

7841  const bool adamw,

7842  const miopenTensorDescriptor_t gradScaleDesc,

7843  const void* gradScale,

7844  const miopenTensorDescriptor_t foundInfDesc,

7845  const void* foundInf);

7846 

7848 // CLOSEOUT SGD DOXYGEN GROUP

7849 #endif // MIOPEN_BETA_API

7850 

7851 #ifdef MIOPEN_BETA_API

7852 // TransformersAdamW APIs

7943 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,

7944  const miopenTensorDescriptor_t paramDesc,

7945  void* param,

7946  const miopenTensorDescriptor_t gradDesc,

7947  const void* grad,

7948  const miopenTensorDescriptor_t expAvgDesc,

7949  void* expAvg,

7950  const miopenTensorDescriptor_t expAvgSqDesc,

7951  void* expAvgSq,

7952  const miopenTensorDescriptor_t stateStepDesc,

7953  void* stateStep,

7954  const unsigned int state_step,

7955  const float lr,

7956  const float beta1,

7957  const float beta2,

7958  const float weight_decay,

7959  const float eps,

7960  const bool correct_bias,

7961  const miopenTensorDescriptor_t gradScaleDesc,

7962  const void* gradScale,

7963  const miopenTensorDescriptor_t foundInfDesc,

7964  const void* foundInf);

7965 

8092 MIOPEN_EXPORT miopenStatus_t

8093 miopenTransformersAdamWWithOutput(miopenHandle_t handle,

8094  const miopenTensorDescriptor_t paramInDesc,

8095  void* paramIn,

8096  const miopenTensorDescriptor_t paramOutDesc,

8097  void* paramOut,

8098  const miopenTensorDescriptor_t paramOutFloat16Desc,

8099  void* paramOutFloat16,

8100  const miopenTensorDescriptor_t gradInDesc,

8101  const void* gradIn,

8102  const miopenTensorDescriptor_t expAvgInDesc,

8103  void* expAvgIn,

8104  const miopenTensorDescriptor_t expAvgOutDesc,

8105  void* expAvgOut,

8106  const miopenTensorDescriptor_t expAvgSqInDesc,

8107  void* expAvgSqIn,

8108  const miopenTensorDescriptor_t expAvgSqOutDesc,

8109  void* expAvgSqOut,

8110  const miopenTensorDescriptor_t stateStepInDesc,

8111  void* stateStepIn,

8112  const miopenTensorDescriptor_t stateStepOutDesc,

8113  void* stateStepOut,

8114  const unsigned int state_step,

8115  const float lr,

8116  const float beta1,

8117  const float beta2,

8118  const float weight_decay,

8119  const float eps,

8120  const float step_size,

8121  const bool correct_bias,

8122  const miopenTensorDescriptor_t gradScaleDesc,

8123  const void* gradScale,

8124  const miopenTensorDescriptor_t foundInfDesc,

8125  const void* foundInf);

8126 

8128 // CLOSEOUT SGD DOXYGEN GROUP

8129 #endif // MIOPEN_BETA_API

8130 

8131 #ifdef MIOPEN_BETA_API

8132 // GetItem APIs

8145 MIOPEN_EXPORT miopenStatus_t

8146 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,

8147  uint32_t indexCount,

8148  const miopenTensorDescriptor_t* indexDescs,

8149  size_t* sizeInBytes);

8150 

8175 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,

8176  void* workspace,

8177  size_t workspaceSizeInBytes,

8178  const miopenTensorDescriptor_t dyDesc,

8179  const void* dy,

8180  uint32_t indexCount,

8181  const miopenTensorDescriptor_t* indexDescs,

8182  const void* const* indexs,

8183  const miopenTensorDescriptor_t dxDesc,

8184  void* dx,

8185  const miopenTensorDescriptor_t errorDesc,

8186  void* error,

8187  uint32_t dimCount,

8188  const int32_t* dims,

8189  uint32_t sliceCount,

8190  const int32_t* slices,

8191  uint32_t offset);

8192 

8194 // CLOSEOUT GETITEM DOXYGEN GROUP

8195 #endif // MIOPEN_BETA_API

8196 

8197 #ifdef MIOPEN_BETA_API

8198 // RotaryPositionalEmbeddings APIs

8216 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,

8217  const miopenTensorDescriptor_t xDesc,

8218  const void* x,

8219  const miopenTensorDescriptor_t cosDesc,

8220  const void* cos,

8221  const miopenTensorDescriptor_t sinDesc,

8222  const void* sin,

8223  const miopenTensorDescriptor_t yDesc,

8224  void* y);

8225 

8239 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,

8240  const miopenTensorDescriptor_t dyDesc,

8241  const void* dy,

8242  const miopenTensorDescriptor_t cosDesc,

8243  const void* cos,

8244  const miopenTensorDescriptor_t sinDesc,

8245  const void* sin,

8246  const miopenTensorDescriptor_t dxDesc,

8247  void* dx);

8249 // CLOSEOUT ROPE DOXYGEN GROUP

8250 // kthvalue APIs

8271 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,

8272  miopenTensorDescriptor_t inputDesc,

8273  const void* input,

8274  miopenTensorDescriptor_t outputDesc,

8275  void* output,

8276  miopenTensorDescriptor_t indicesDesc,

8277  size_t* indices,

8278  size_t k,

8279  int32_t dim = -1,

8280  bool keepDim = false);

8281 

8283 // CLOSEOUT kthvalue DOXYGEN GROUP

8284 #endif // MIOPEN_BETA_API

8285 

8286 #ifdef MIOPEN_BETA_API

8300 MIOPEN_EXPORT miopenStatus_t

8301 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,

8302  miopenTensorDescriptor_t inputDesc,

8303  miopenTensorDescriptor_t weightDesc,

8304  size_t* sizeInBytes);

8305 

8322 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,

8323  void* workspace,

8324  size_t workspaceSizeInBytes,

8325  miopenTensorDescriptor_t inputDesc,

8326  const void* input,

8327  miopenTensorDescriptor_t weightDesc,

8328  const void* weight,

8329  miopenTensorDescriptor_t doutputDesc,

8330  const void* doutput,

8331  miopenTensorDescriptor_t dinputDesc,

8332  void* dinput,

8333  miopenTensorDescriptor_t dweightDesc,

8334  void* dweight);

8335 

8337 // CLOSEOUT RELU DOXYGEN GROUP

8338 #endif // MIOPEN_BETA_API

8339 

8340 #ifdef MIOPEN_BETA_API

8341 

8346 typedef enum

8347 {

8348  MIOPEN_LOSS_REDUCTION_NONE = 0,

8349  MIOPEN_LOSS_REDUCTION_SUM = 1,

8350  MIOPEN_LOSS_REDUCTION_MEAN = 2,

8352 } miopenLossReductionMode_t;

8353 

8354 // SoftMarginLoss APIs

8372 MIOPEN_EXPORT miopenStatus_t

8373 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8374  miopenTensorDescriptor_t inputDesc,

8375  miopenTensorDescriptor_t targetDesc,

8376  miopenTensorDescriptor_t outputDesc,

8377  miopenLossReductionMode_t reduction,

8378  size_t* sizeInBytes);

8379 

8396 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,

8397  miopenTensorDescriptor_t inputDesc,

8398  const void* input,

8399  miopenTensorDescriptor_t targetDesc,

8400  const void* target,

8401  miopenTensorDescriptor_t outputDesc,

8402  void* output,

8403  miopenLossReductionMode_t reduction,

8404  void* workspace = nullptr,

8405  size_t workspaceSizeInBytes = 0);

8406 

8421 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,

8422  miopenTensorDescriptor_t inputDesc,

8423  const void* input,

8424  miopenTensorDescriptor_t targetDesc,

8425  const void* target,

8426  miopenTensorDescriptor_t doutputDesc,

8427  const void* doutput,

8428  miopenTensorDescriptor_t dinputDesc,

8429  void* dinput,

8430  miopenLossReductionMode_t reduction);

8431 

8433 // CLOSEOUT LossFunction DOXYGEN GROUP

8434 #endif

8435 

8436 #ifdef MIOPEN_BETA_API

8437 // MultiMarginLoss APIs

8461 MIOPEN_EXPORT miopenStatus_t

8462 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8463  miopenTensorDescriptor_t inputDesc,

8464  miopenTensorDescriptor_t targetDesc,

8465  miopenTensorDescriptor_t weightDesc,

8466  miopenTensorDescriptor_t outputDesc,

8467  long p,

8468  float margin,

8469  miopenLossReductionMode_t reduction,

8470  size_t* sizeInBytes);

8471 

8499 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,

8500  miopenTensorDescriptor_t inputDesc,

8501  const void* input,

8502  miopenTensorDescriptor_t targetDesc,

8503  const void* target,

8504  miopenTensorDescriptor_t weightDesc,

8505  const void* weight,

8506  miopenTensorDescriptor_t outputDesc,

8507  void* output,

8508  long p,

8509  float margin,

8510  miopenLossReductionMode_t reduction,

8511  void* workspace,

8512  size_t workspaceSizeInBytes);

8513 

8515 // CLOSEOUT LossFunction DOXYGEN GROUP

8516 #endif // MIOPEN_BETA_API

8517 

8530 typedef enum

8531 {

8532  miopenTuningPolicyNone = 1, /* do not enforce anything */

8533  miopenTuningPolicyDbUpdate = 2, /* tune and update the db */

8534  miopenTuningPolicySearch =

8535  3, /* search db first, if record not found tune but do not update the db */

8536  miopenTuningPolicySearchDbUpdate = 4, /* combination of Search and DbUpdate */

8537  miopenTuningPolicyDbClean = 5, /* remove existing entry, do not tune */

8538 } miopenTuningPolicy_t;

8539 

8548 MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,

8549  miopenTuningPolicy_t newValue);

8550 

8558 MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,

8559  miopenTuningPolicy_t* value);

8560 

8561 #ifdef __cplusplus

8562 }

8563 #endif

8564 

8565 #ifdef __clang__

8566 #pragma clang diagnostic pop

8567 #endif

8568 

8569 #endif // MIOPEN_GUARD_MIOPEN_H_

miopenCreateOpActivationBackward

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

Creates a backward activation operator.

miopenCreateOpBatchNormForward

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

Creates a forward training batch normalization operator.

miopenFusionPlanConvolutionGetAlgo

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

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

miopenFusionPlanGetWorkSpaceSize

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

Query the workspace size required for the fusion plan.

miopenFusionPlanConvolutionSetAlgo

miopenStatus_t miopenFusionPlanConvolutionSetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo)

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

miopenCreateOpBatchNormInference

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

Creates a forward inference batch normalization operator.

miopenSetOpArgsBiasForward

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

Sets the arguments for forward bias op.

miopenCreateOpConvForward

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

Creates forward convolution operator.

miopenSetOpArgsBatchNormInference

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

Sets the arguments for inference batch normalization op.

miopenSetOpArgsBatchNormForward

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

Sets the arguments for forward batch normalization op.

miopenExecuteFusionPlan

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

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

miopenFusionPlanGetOp

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

Allows access to the operators in a fusion plan.

miopenDestroyFusionPlan

miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc)

Destroy the fusion plan descriptor object.

miopenCreateOpActivationForward

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

Creates a forward activation operator.

miopenExecuteFusionPlan_v2

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

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

miopenFusionDirection_t

miopenFusionDirection_t

Kernel fusion direction in the network.

Definition: miopen.h:3604

miopenSetOpArgsActivBackward

miopenStatus_t miopenSetOpArgsActivBackward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t activBwdOp, const void *alpha, const void *beta, const void *y, const void *reserved, double activAlpha, double activBeta, double activGamma)

Sets the arguments for backward activation op.

miopenCompileFusionPlan

miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle, miopenFusionPlanDescriptor_t fusePlanDesc)

Compiles the fusion plan.

miopenSetOpArgsBatchNormBackward

miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t bnOp, const void *alpha, const void *beta, const void *x, const void *bnScale, const void *bnBias, void *resultBnScaleDiff, void *resultBnBiasDiff, const void *savedMean, const void *savedInvVariance)

Sets the arguments for backward batch normalization op.

miopenSetOpArgsActivForward

miopenStatus_t miopenSetOpArgsActivForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t activFwdOp, const void *alpha, const void *beta, double activAlpha, double activBeta, double activGamma)

Sets the arguments for forward activation op.

miopenDestroyOperatorArgs

miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args)

Destroys an operator argument object.

miopenCreateOpBatchNormBackward

miopenStatus_t miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *bnBwdOp, const miopenBatchNormMode_t bn_mode)

Creates a back propagation batch normalization operator.

miopenCreateOperatorArgs

miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t *args)

Creates an operator argument object.

miopenSetOpArgsConvForward

miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args, const miopenFusionOpDescriptor_t convOp, const void *alpha, const void *beta, const void *w)

Sets the arguments for forward convolution op.

miopenConvolutionBiasActivationForward

miopenStatus_t miopenConvolutionBiasActivationForward(miopenHandle_t handle, const void *alpha1, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t wDesc, const void *w, const miopenConvolutionDescriptor_t convDesc, miopenConvFwdAlgorithm_t algo, void *workspace, size_t workspaceSizeInBytes, const void *alpha2, const miopenTensorDescriptor_t zDesc, const void *z, const miopenTensorDescriptor_t biasDesc, const void *bias, const miopenActivationDescriptor_t activationDesc, const miopenTensorDescriptor_t yDesc, void *y)

Prepares and executes the Convlution+Bias+Activation Fusion.

miopenCreateFusionPlan

miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t *fusePlanDesc, const miopenFusionDirection_t fuseDirection, const miopenTensorDescriptor_t inputDesc)

Creates the kenrel fusion plan descriptor object.

miopenCreateOpBiasForward

miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc, miopenFusionOpDescriptor_t *biasOp, const miopenTensorDescriptor_t bDesc)

Creates a forward bias operator.

miopenHorizontalFusion

@ miopenHorizontalFusion

Definition: miopen.h:3606

miopenVerticalFusion

@ miopenVerticalFusion

Definition: miopen.h:3605

miopenBackendExecute

miopenStatus_t miopenBackendExecute(miopenHandle_t handle, miopenBackendDescriptor_t executionPlan, miopenBackendDescriptor_t variantPack)

Executes a graph.

miopenBackendHeurMode_t

miopenBackendHeurMode_t

Operation mode of CUDNN_BACKEND_ENGINEHEUR_DESCRIPTOR.

Definition: miopen.h:7298

miopenPointwiseMode_t

miopenPointwiseMode_t

Intended poinwise math operation for a pointwise operation descriptor.

Definition: miopen.h:7098

miopenBackendFinalize

miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor)

Finalizes a backend descriptor.

miopenBackendInitialize

miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor, miopenBackendDescriptorType_t descriptorType, size_t sizeInBytes)

Repurposes an instance of miopenBackendDescriptor_t.

miopenBackendAttributeName_t

miopenBackendAttributeName_t

Backend Descriptor's Attribute.

Definition: miopen.h:6805

miopenRngDistribution_t

miopenRngDistribution_t

Distribution for random number generation.

Definition: miopen.h:7274

miopenBackendDescriptorType_t

miopenBackendDescriptorType_t

Descriptor type.

Definition: miopen.h:6762

miopenBackendSetAttribute

miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor, miopenBackendAttributeName_t attributeName, miopenBackendAttributeType_t attributeType, int64_t elementCount, void *arrayOfElements)

Sets an attribute of a descriptor.

miopenBackendGetAttribute

miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor, miopenBackendAttributeName_t attributeName, miopenBackendAttributeType_t attributeType, int64_t requestedElementCount, int64_t *elementCount, void *arrayOfElements)

Retrieves backend descriptor's attribute.

miopenBackendCreateDescriptor

miopenStatus_t miopenBackendCreateDescriptor(miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t *descriptor)

Backend descriptor.

miopenAlphaBetaCase_t

miopenAlphaBetaCase_t

Definition: miopen.h:7281

miopenBackendDestroyDescriptor

miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor)

Destroys an instance of miopenBackendDescriptor_t.

miopenBackendAttributeType_t

miopenBackendAttributeType_t

Data type of an attribute of a backend descriptor.

Definition: miopen.h:7059

MIOPEN_HEUR_MODE_INSTANT

@ MIOPEN_HEUR_MODE_INSTANT

Definition: miopen.h:7299

MIOPEN_HEUR_MODE_A

@ MIOPEN_HEUR_MODE_A

Definition: miopen.h:7302

MIOPEN_HEUR_MODE_B

@ MIOPEN_HEUR_MODE_B

Definition: miopen.h:7300

MIOPEN_HEUR_MODES_COUNT

@ MIOPEN_HEUR_MODES_COUNT

Definition: miopen.h:7303

MIOPEN_HEUR_MODE_FALLBACK

@ MIOPEN_HEUR_MODE_FALLBACK

Definition: miopen.h:7301

MIOPEN_POINTWISE_SOFTPLUS_FWD

@ MIOPEN_POINTWISE_SOFTPLUS_FWD

Definition: miopen.h:7186

MIOPEN_POINTWISE_ELU_FWD

@ MIOPEN_POINTWISE_ELU_FWD

Definition: miopen.h:7179

MIOPEN_POINTWISE_RELU_FWD

@ MIOPEN_POINTWISE_RELU_FWD

Definition: miopen.h:7170

MIOPEN_POINTWISE_DIV

@ MIOPEN_POINTWISE_DIV

Definition: miopen.h:7107

MIOPEN_POINTWISE_SIGMOID_BWD

@ MIOPEN_POINTWISE_SIGMOID_BWD

Definition: miopen.h:7204

MIOPEN_POINTWISE_POW

@ MIOPEN_POINTWISE_POW

Definition: miopen.h:7123

MIOPEN_POINTWISE_MOD

@ MIOPEN_POINTWISE_MOD

Definition: miopen.h:7117

MIOPEN_POINTWISE_SQRT

@ MIOPEN_POINTWISE_SQRT

Definition: miopen.h:7156

MIOPEN_POINTWISE_BINARY_SELECT

@ MIOPEN_POINTWISE_BINARY_SELECT

Definition: miopen.h:7261

MIOPEN_POINTWISE_GELU_BWD

@ MIOPEN_POINTWISE_GELU_BWD

Definition: miopen.h:7212

MIOPEN_POINTWISE_MIN

@ MIOPEN_POINTWISE_MIN

Definition: miopen.h:7113

MIOPEN_POINTWISE_CMP_NEQ

@ MIOPEN_POINTWISE_CMP_NEQ

Definition: miopen.h:7231

MIOPEN_POINTWISE_FLOOR

@ MIOPEN_POINTWISE_FLOOR

Definition: miopen.h:7141

MIOPEN_POINTWISE_RSQRT

@ MIOPEN_POINTWISE_RSQRT

Definition: miopen.h:7150

MIOPEN_POINTWISE_CMP_EQ

@ MIOPEN_POINTWISE_CMP_EQ

Definition: miopen.h:7228

MIOPEN_POINTWISE_CMP_GE

@ MIOPEN_POINTWISE_CMP_GE

Definition: miopen.h:7238

MIOPEN_POINTWISE_ADD_SQUARE

@ MIOPEN_POINTWISE_ADD_SQUARE

Definition: miopen.h:7104

MIOPEN_POINTWISE_ERF

@ MIOPEN_POINTWISE_ERF

Definition: miopen.h:7162

MIOPEN_POINTWISE_SWISH_FWD

@ MIOPEN_POINTWISE_SWISH_FWD

Definition: miopen.h:7189

MIOPEN_POINTWISE_LOG

@ MIOPEN_POINTWISE_LOG

Definition: miopen.h:7144

MIOPEN_POINTWISE_SUB

@ MIOPEN_POINTWISE_SUB

Definition: miopen.h:7126

MIOPEN_POINTWISE_NEG

@ MIOPEN_POINTWISE_NEG

Definition: miopen.h:7147

MIOPEN_POINTWISE_LOGICAL_AND

@ MIOPEN_POINTWISE_LOGICAL_AND

Definition: miopen.h:7248

MIOPEN_POINTWISE_SWISH_BWD

@ MIOPEN_POINTWISE_SWISH_BWD

Definition: miopen.h:7218

MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

Definition: miopen.h:7194

MIOPEN_POINTWISE_SIN

@ MIOPEN_POINTWISE_SIN

Definition: miopen.h:7153

MIOPEN_POINTWISE_RECIPROCAL

@ MIOPEN_POINTWISE_RECIPROCAL

Definition: miopen.h:7265

MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

Definition: miopen.h:7225

MIOPEN_POINTWISE_GELU_FWD

@ MIOPEN_POINTWISE_GELU_FWD

Definition: miopen.h:7183

MIOPEN_POINTWISE_ABS

@ MIOPEN_POINTWISE_ABS

Definition: miopen.h:7129

MIOPEN_POINTWISE_CMP_LT

@ MIOPEN_POINTWISE_CMP_LT

Definition: miopen.h:7241

MIOPEN_POINTWISE_EXP

@ MIOPEN_POINTWISE_EXP

Definition: miopen.h:7138

MIOPEN_POINTWISE_GEN_INDEX

@ MIOPEN_POINTWISE_GEN_INDEX

Definition: miopen.h:7257

MIOPEN_POINTWISE_CEIL

@ MIOPEN_POINTWISE_CEIL

Definition: miopen.h:7132

MIOPEN_POINTWISE_LOGICAL_NOT

@ MIOPEN_POINTWISE_LOGICAL_NOT

Definition: miopen.h:7254

MIOPEN_POINTWISE_SIGMOID_FWD

@ MIOPEN_POINTWISE_SIGMOID_FWD

Definition: miopen.h:7176

MIOPEN_POINTWISE_SOFTPLUS_BWD

@ MIOPEN_POINTWISE_SOFTPLUS_BWD

Definition: miopen.h:7215

MIOPEN_POINTWISE_LOGICAL_OR

@ MIOPEN_POINTWISE_LOGICAL_OR

Definition: miopen.h:7251

MIOPEN_POINTWISE_TAN

@ MIOPEN_POINTWISE_TAN

Definition: miopen.h:7159

MIOPEN_POINTWISE_ELU_BWD

@ MIOPEN_POINTWISE_ELU_BWD

Definition: miopen.h:7208

MIOPEN_POINTWISE_IDENTITY

@ MIOPEN_POINTWISE_IDENTITY

Definition: miopen.h:7167

MIOPEN_POINTWISE_CMP_LE

@ MIOPEN_POINTWISE_CMP_LE

Definition: miopen.h:7245

MIOPEN_POINTWISE_COS

@ MIOPEN_POINTWISE_COS

Definition: miopen.h:7135

MIOPEN_POINTWISE_TANH_BWD

@ MIOPEN_POINTWISE_TANH_BWD

Definition: miopen.h:7201

MIOPEN_POINTWISE_MUL

@ MIOPEN_POINTWISE_MUL

Definition: miopen.h:7120

MIOPEN_POINTWISE_TANH_FWD

@ MIOPEN_POINTWISE_TANH_FWD

Definition: miopen.h:7173

MIOPEN_POINTWISE_RELU_BWD

@ MIOPEN_POINTWISE_RELU_BWD

Definition: miopen.h:7198

MIOPEN_POINTWISE_ADD

@ MIOPEN_POINTWISE_ADD

Definition: miopen.h:7100

MIOPEN_POINTWISE_MAX

@ MIOPEN_POINTWISE_MAX

Definition: miopen.h:7110

MIOPEN_POINTWISE_CMP_GT

@ MIOPEN_POINTWISE_CMP_GT

Definition: miopen.h:7234

MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

Definition: miopen.h:7022

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

Definition: miopen.h:6852

MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

Definition: miopen.h:6976

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

Definition: miopen.h:6979

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

Definition: miopen.h:6858

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

Definition: miopen.h:6849

MIOPEN_ATTR_OPERATION_SIGNAL_MODE

@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE

Definition: miopen.h:7000

MIOPEN_ATTR_OPERATION_RNG_DESC

@ MIOPEN_ATTR_OPERATION_RNG_DESC

Definition: miopen.h:7046

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

Definition: miopen.h:6850

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

Definition: miopen.h:6963

MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

Definition: miopen.h:7025

MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

Definition: miopen.h:7013

MIOPEN_ATTR_OPERATIONGRAPH_OPS

@ MIOPEN_ATTR_OPERATIONGRAPH_OPS

Definition: miopen.h:6902

MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

Definition: miopen.h:6926

MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

Definition: miopen.h:6821

MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

Definition: miopen.h:7004

MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

Definition: miopen.h:7029

MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

Definition: miopen.h:7032

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

Definition: miopen.h:6993

MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

Definition: miopen.h:6822

MIOPEN_ATTR_REDUCTION_OPERATOR

@ MIOPEN_ATTR_REDUCTION_OPERATOR

Definition: miopen.h:6950

MIOPEN_ATTR_OPERATION_MATMUL_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_DESC

Definition: miopen.h:6944

MIOPEN_ATTR_CONVOLUTION_DILATIONS

@ MIOPEN_ATTR_CONVOLUTION_DILATIONS

Definition: miopen.h:6819

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

Definition: miopen.h:6987

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

Definition: miopen.h:6871

MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

Definition: miopen.h:6971

MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

Definition: miopen.h:6837

MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

Definition: miopen.h:7009

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

Definition: miopen.h:6891

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

Definition: miopen.h:6959

MIOPEN_ATTR_KNOB_INFO_TYPE

@ MIOPEN_ATTR_KNOB_INFO_TYPE

Definition: miopen.h:6925

MIOPEN_ATTR_LAYOUT_INFO_TYPES

@ MIOPEN_ATTR_LAYOUT_INFO_TYPES

Definition: miopen.h:6923

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

Definition: miopen.h:6885

MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

Definition: miopen.h:6901

MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

Definition: miopen.h:7026

MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

Definition: miopen.h:7041

MIOPEN_ATTR_POINTWISE_MATH_PREC

@ MIOPEN_ATTR_POINTWISE_MATH_PREC

Definition: miopen.h:6807

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

Definition: miopen.h:6947

MIOPEN_ATTR_OPERATION_GENSTATS_MODE

@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE

Definition: miopen.h:6877

MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

Definition: miopen.h:6847

MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

Definition: miopen.h:6919

MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

Definition: miopen.h:6954

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

Definition: miopen.h:6862

MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

Definition: miopen.h:6920

MIOPEN_ATTR_TENSOR_IS_BY_VALUE

@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE

Definition: miopen.h:6913

MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

Definition: miopen.h:7006

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

Definition: miopen.h:6851

MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

Definition: miopen.h:6883

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

Definition: miopen.h:7016

MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

Definition: miopen.h:7034

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

Definition: miopen.h:6992

MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

Definition: miopen.h:6868

MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

Definition: miopen.h:6917

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

Definition: miopen.h:6962

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

Definition: miopen.h:6982

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

Definition: miopen.h:6887

MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

Definition: miopen.h:7002

MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

Definition: miopen.h:7001

MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

Definition: miopen.h:6875

MIOPEN_ATTR_ENGINEHEUR_RESULTS

@ MIOPEN_ATTR_ENGINEHEUR_RESULTS

Definition: miopen.h:6827

MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

Definition: miopen.h:6905

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

Definition: miopen.h:6865

MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

Definition: miopen.h:6897

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

Definition: miopen.h:6967

MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

Definition: miopen.h:6878

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7015

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

Definition: miopen.h:6895

MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

Definition: miopen.h:6834

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

Definition: miopen.h:6961

MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

Definition: miopen.h:6998

MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

Definition: miopen.h:7028

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

Definition: miopen.h:6856

MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

Definition: miopen.h:6836

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

Definition: miopen.h:6859

MIOPEN_ATTR_TENSOR_VECTOR_COUNT

@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT

Definition: miopen.h:6909

MIOPEN_ATTR_OPERATION_MATMUL_CDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC

Definition: miopen.h:6943

MIOPEN_ATTR_REDUCTION_COMP_TYPE

@ MIOPEN_ATTR_REDUCTION_COMP_TYPE

Definition: miopen.h:6951

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

Definition: miopen.h:6990

MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

Definition: miopen.h:6910

MIOPEN_ATTR_TENSOR_DIMENSIONS

@ MIOPEN_ATTR_TENSOR_DIMENSIONS

Definition: miopen.h:6907

MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

Definition: miopen.h:6880

MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

Definition: miopen.h:6997

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

Definition: miopen.h:6872

MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

Definition: miopen.h:6933

MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

Definition: miopen.h:6935

MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

Definition: miopen.h:6839

MIOPEN_ATTR_RESAMPLE_STRIDES

@ MIOPEN_ATTR_RESAMPLE_STRIDES

Definition: miopen.h:6974

MIOPEN_ATTR_POINTWISE_ELU_ALPHA

@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA

Definition: miopen.h:6812

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

Definition: miopen.h:7018

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

Definition: miopen.h:6988

MIOPEN_ATTR_OPERATION_RNG_SEED

@ MIOPEN_ATTR_OPERATION_RNG_SEED

Definition: miopen.h:7045

MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

Definition: miopen.h:7023

MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

Definition: miopen.h:6873

MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

Definition: miopen.h:6996

MIOPEN_ATTR_RESAMPLE_MODE

@ MIOPEN_ATTR_RESAMPLE_MODE

Definition: miopen.h:6969

MIOPEN_ATTR_RNG_DISTRIBUTION

@ MIOPEN_ATTR_RNG_DISTRIBUTION

Definition: miopen.h:7037

MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

Definition: miopen.h:7024

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

Definition: miopen.h:6946

MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

Definition: miopen.h:7007

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

Definition: miopen.h:6811

MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

Definition: miopen.h:7035

MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

Definition: miopen.h:6918

MIOPEN_ATTR_POINTWISE_AXIS

@ MIOPEN_ATTR_POINTWISE_AXIS

Definition: miopen.h:6815

MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

Definition: miopen.h:7019

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

Definition: miopen.h:6809

MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

Definition: miopen.h:6930

MIOPEN_ATTR_OPERATION_MATMUL_BDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC

Definition: miopen.h:6942

MIOPEN_ATTR_TENSOR_DATA_TYPE

@ MIOPEN_ATTR_TENSOR_DATA_TYPE

Definition: miopen.h:6906

MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

Definition: miopen.h:7003

MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

Definition: miopen.h:6927

MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

Definition: miopen.h:7012

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

Definition: miopen.h:6984

MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

Definition: miopen.h:6973

MIOPEN_ATTR_MATMUL_COMP_TYPE

@ MIOPEN_ATTR_MATMUL_COMP_TYPE

Definition: miopen.h:6938

MIOPEN_ATTR_TENSOR_UNIQUE_ID

@ MIOPEN_ATTR_TENSOR_UNIQUE_ID

Definition: miopen.h:6911

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

Definition: miopen.h:6965

MIOPEN_ATTR_OPERATION_CONCAT_AXIS

@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS

Definition: miopen.h:6995

MIOPEN_ATTR_OPERATION_RNG_YDESC

@ MIOPEN_ATTR_OPERATION_RNG_YDESC

Definition: miopen.h:7044

MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

Definition: miopen.h:6931

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

Definition: miopen.h:6857

MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

Definition: miopen.h:6826

MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

Definition: miopen.h:6915

MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

Definition: miopen.h:6813

MIOPEN_ATTR_TENSOR_IS_VIRTUAL

@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL

Definition: miopen.h:6912

MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

Definition: miopen.h:6832

MIOPEN_ATTR_MATMUL_PADDING_VALUE

@ MIOPEN_ATTR_MATMUL_PADDING_VALUE

Definition: miopen.h:6939

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

Definition: miopen.h:6899

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

Definition: miopen.h:6894

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

Definition: miopen.h:6853

MIOPEN_ATTR_KNOB_INFO_STRIDE

@ MIOPEN_ATTR_KNOB_INFO_STRIDE

Definition: miopen.h:6928

MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

Definition: miopen.h:6975

MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

Definition: miopen.h:6870

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

Definition: miopen.h:6980

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

Definition: miopen.h:6960

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

Definition: miopen.h:6860

MIOPEN_ATTR_CONVOLUTION_CONV_MODE

@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE

Definition: miopen.h:6818

MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

Definition: miopen.h:6953

MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

Definition: miopen.h:6838

MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

Definition: miopen.h:6884

MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

Definition: miopen.h:6936

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

Definition: miopen.h:6896

MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

Definition: miopen.h:6846

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

Definition: miopen.h:6986

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

Definition: miopen.h:6889

MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

Definition: miopen.h:6874

MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

Definition: miopen.h:7014

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

Definition: miopen.h:6966

MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

Definition: miopen.h:7047

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

Definition: miopen.h:6854

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

Definition: miopen.h:6890

MIOPEN_ATTR_ENGINE_LAYOUT_INFO

@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO

Definition: miopen.h:6934

MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

Definition: miopen.h:6841

MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

Definition: miopen.h:6817

MIOPEN_ATTR_RESAMPLE_COMP_TYPE

@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE

Definition: miopen.h:6970

MIOPEN_ATTR_ENGINECFG_ENGINE

@ MIOPEN_ATTR_ENGINECFG_ENGINE

Definition: miopen.h:6830

MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

Definition: miopen.h:6972

MIOPEN_ATTR_RESAMPLE_PADDING_MODE

@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE

Definition: miopen.h:6977

MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

Definition: miopen.h:6823

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7017

MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

Definition: miopen.h:6879

MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

Definition: miopen.h:7010

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

Definition: miopen.h:6886

MIOPEN_ATTR_ENGINE_KNOB_INFO

@ MIOPEN_ATTR_ENGINE_KNOB_INFO

Definition: miopen.h:6932

MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

Definition: miopen.h:6945

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

Definition: miopen.h:6864

MIOPEN_ATTR_TENSOR_REORDERING_MODE

@ MIOPEN_ATTR_TENSOR_REORDERING_MODE

Definition: miopen.h:6914

MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

Definition: miopen.h:6842

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

Definition: miopen.h:6948

MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

Definition: miopen.h:6867

MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

Definition: miopen.h:7039

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

Definition: miopen.h:6843

MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

Definition: miopen.h:6922

MIOPEN_ATTR_ENGINEHEUR_MODE

@ MIOPEN_ATTR_ENGINEHEUR_MODE

Definition: miopen.h:6825

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

Definition: miopen.h:6989

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

Definition: miopen.h:6991

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

Definition: miopen.h:6898

MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

Definition: miopen.h:6869

MIOPEN_ATTR_POINTWISE_MODE

@ MIOPEN_ATTR_POINTWISE_MODE

Definition: miopen.h:6806

MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

Definition: miopen.h:6831

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

Definition: miopen.h:6866

MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

Definition: miopen.h:7031

MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

Definition: miopen.h:6808

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

Definition: miopen.h:6844

MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

Definition: miopen.h:6810

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

Definition: miopen.h:6964

MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

Definition: miopen.h:7042

MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

Definition: miopen.h:6828

MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

Definition: miopen.h:6888

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

Definition: miopen.h:6892

MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

Definition: miopen.h:7038

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

Definition: miopen.h:6957

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

Definition: miopen.h:6958

MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

Definition: miopen.h:7020

MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

Definition: miopen.h:7011

MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

Definition: miopen.h:6881

MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

Definition: miopen.h:6835

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

Definition: miopen.h:6983

MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

Definition: miopen.h:7030

MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

Definition: miopen.h:7027

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

Definition: miopen.h:6855

MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

Definition: miopen.h:7040

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

Definition: miopen.h:6863

MIOPEN_ATTR_TENSOR_STRIDES

@ MIOPEN_ATTR_TENSOR_STRIDES

Definition: miopen.h:6908

MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

Definition: miopen.h:6820

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

Definition: miopen.h:6861

MIOPEN_ATTR_POINTWISE_SWISH_BETA

@ MIOPEN_ATTR_POINTWISE_SWISH_BETA

Definition: miopen.h:6814

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

Definition: miopen.h:6981

MIOPEN_ATTR_OPERATION_REDUCTION_DESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC

Definition: miopen.h:6955

MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

Definition: miopen.h:7008

MIOPEN_ATTR_OPERATION_MATMUL_ADESC

@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC

Definition: miopen.h:6941

MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

Definition: miopen.h:6903

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

Definition: miopen.h:6893

MIOPEN_RNG_DISTRIBUTION_BERNOULLI

@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI

Definition: miopen.h:7275

MIOPEN_RNG_DISTRIBUTION_UNIFORM

@ MIOPEN_RNG_DISTRIBUTION_UNIFORM

Definition: miopen.h:7276

MIOPEN_RNG_DISTRIBUTION_NORMAL

@ MIOPEN_RNG_DISTRIBUTION_NORMAL

Definition: miopen.h:7277

MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

Definition: miopen.h:6773

MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

Definition: miopen.h:6791

MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

Definition: miopen.h:6765

MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

Definition: miopen.h:6789

MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

Definition: miopen.h:6784

MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

Definition: miopen.h:6763

MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

Definition: miopen.h:6786

MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

Definition: miopen.h:6770

MIOPEN_BACKEND_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_RNG_DESCRIPTOR

Definition: miopen.h:6792

MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

Definition: miopen.h:6781

MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

Definition: miopen.h:6780

MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

Definition: miopen.h:6766

MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

Definition: miopen.h:6785

MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

Definition: miopen.h:6771

MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

Definition: miopen.h:6782

MIOPEN_BACKEND_TENSOR_DESCRIPTOR

@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR

Definition: miopen.h:6793

MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

Definition: miopen.h:6783

MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

Definition: miopen.h:6788

MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

Definition: miopen.h:6776

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

Definition: miopen.h:6775

MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

Definition: miopen.h:6768

MIOPEN_BACKEND_ENGINE_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR

Definition: miopen.h:6764

MIOPEN_BACKEND_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR

Definition: miopen.h:6772

MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

Definition: miopen.h:6777

MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

Definition: miopen.h:6794

MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

Definition: miopen.h:6790

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

Definition: miopen.h:6774

MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

Definition: miopen.h:6778

MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

Definition: miopen.h:6779

MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

Definition: miopen.h:6787

MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

Definition: miopen.h:6767

MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

Definition: miopen.h:6769

SCALE

@ SCALE

Definition: miopen.h:7288

BILINEAR

@ BILINEAR

Definition: miopen.h:7289

DEFAULT

@ DEFAULT

Definition: miopen.h:7287

ERROR_STATE

@ ERROR_STATE

Definition: miopen.h:7290

MIOPEN_TYPE_RNG_DISTRIBUTION

@ MIOPEN_TYPE_RNG_DISTRIBUTION

Definition: miopen.h:7089

MIOPEN_TYPE_FLOAT

@ MIOPEN_TYPE_FLOAT

Definition: miopen.h:7064

MIOPEN_TYPE_NUMERICAL_NOTE

@ MIOPEN_TYPE_NUMERICAL_NOTE

Definition: miopen.h:7071

MIOPEN_TYPE_RESAMPLE_MODE

@ MIOPEN_TYPE_RESAMPLE_MODE

Definition: miopen.h:7081

MIOPEN_TYPE_INT32

@ MIOPEN_TYPE_INT32

Definition: miopen.h:7083

MIOPEN_TYPE_POINTWISE_MODE

@ MIOPEN_TYPE_POINTWISE_MODE

Definition: miopen.h:7074

MIOPEN_TYPE_HANDLE

@ MIOPEN_TYPE_HANDLE

Definition: miopen.h:7060

MIOPEN_TYPE_HEUR_MODE

@ MIOPEN_TYPE_HEUR_MODE

Definition: miopen.h:7068

MIOPEN_TYPE_CONVOLUTION_MODE

@ MIOPEN_TYPE_CONVOLUTION_MODE

Definition: miopen.h:7067

MIOPEN_TYPE_TENSOR_REORDERING_MODE

@ MIOPEN_TYPE_TENSOR_REORDERING_MODE

Definition: miopen.h:7080

MIOPEN_TYPE_BOOLEAN

@ MIOPEN_TYPE_BOOLEAN

Definition: miopen.h:7062

MIOPEN_TYPE_NORM_MODE

@ MIOPEN_TYPE_NORM_MODE

Definition: miopen.h:7087

MIOPEN_TYPE_FRACTION

@ MIOPEN_TYPE_FRACTION

Definition: miopen.h:7086

MIOPEN_TYPE_BACKEND_DESCRIPTOR

@ MIOPEN_TYPE_BACKEND_DESCRIPTOR

Definition: miopen.h:7075

MIOPEN_TYPE_ATTRIB_NAME

@ MIOPEN_TYPE_ATTRIB_NAME

Definition: miopen.h:7073

MIOPEN_TYPE_BEHAVIOR_NOTE

@ MIOPEN_TYPE_BEHAVIOR_NOTE

Definition: miopen.h:7079

MIOPEN_TYPE_DATA_TYPE

@ MIOPEN_TYPE_DATA_TYPE

Definition: miopen.h:7061

MIOPEN_TYPE_NAN_PROPOGATION

@ MIOPEN_TYPE_NAN_PROPOGATION

Definition: miopen.h:7070

MIOPEN_TYPE_DOUBLE

@ MIOPEN_TYPE_DOUBLE

Definition: miopen.h:7065

MIOPEN_TYPE_SIGNAL_MODE

@ MIOPEN_TYPE_SIGNAL_MODE

Definition: miopen.h:7085

MIOPEN_TYPE_CHAR

@ MIOPEN_TYPE_CHAR

Definition: miopen.h:7084

MIOPEN_TYPE_PADDING_MODE

@ MIOPEN_TYPE_PADDING_MODE

Definition: miopen.h:7082

MIOPEN_TYPE_INT64

@ MIOPEN_TYPE_INT64

Definition: miopen.h:7063

MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

Definition: miopen.h:7078

MIOPEN_TYPE_LAYOUT_TYPE

@ MIOPEN_TYPE_LAYOUT_TYPE

Definition: miopen.h:7072

MIOPEN_TYPE_GENSTATS_MODE

@ MIOPEN_TYPE_GENSTATS_MODE

Definition: miopen.h:7076

MIOPEN_TYPE_VOID_PTR

@ MIOPEN_TYPE_VOID_PTR

Definition: miopen.h:7066

MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

Definition: miopen.h:7077

MIOPEN_TYPE_KNOB_TYPE

@ MIOPEN_TYPE_KNOB_TYPE

Definition: miopen.h:7069

MIOPEN_TYPE_NORM_FWD_PHASE

@ MIOPEN_TYPE_NORM_FWD_PHASE

Definition: miopen.h:7088

miopenSetLRNDescriptor

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

Sets a LRN layer descriptor details.

miopenCreateLRNDescriptor

miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t *lrnDesc)

Creates a local response normalization (LRN) layer descriptor.

miopenGetLRNDescriptor

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

Gets a LRN layer descriptor details.

miopenLRNBackward

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

Execute a LRN backward layer.

miopenLRNGetWorkSpaceSize

miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Determine the workspace requirements.

miopenLRNMode_t

miopenLRNMode_t

Definition: miopen.h:475

miopenLRNForward

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

Execute a LRN forward layer.

miopenDestroyLRNDescriptor

miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc)

Destroys the LRN descriptor object.

miopenGetCTCLossWorkspaceSize

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

Query the amount of memory required to execute miopenCTCLoss.

miopenGetSoftMarginLossForwardWorkspaceSize

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

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

miopenLossReductionMode_t

miopenLossReductionMode_t

Definition: miopen.h:8347

miopenGetMultiMarginLossForwardWorkspaceSize

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

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

miopenCTCLossAlgo_t

miopenCTCLossAlgo_t

Definition: miopen.h:5462

miopenSetCTCLossDescriptor

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

Set the details of a CTC loss function descriptor.

miopenCTCLoss

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

Execute forward inference for CTCLoss layer.

miopenGetCTCLossDescriptor

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

Retrieves a CTC loss function descriptor's details.

miopenCreateCTCLossDescriptor

miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t *ctcLossDesc)

Create a CTC loss function Descriptor.

miopenMultiMarginLossForward

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

Execute a MultiMarginLoss forward layer.

miopenSoftMarginLossBackward

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

Execute a SoftMarginLoss backward layer.

miopenSoftMarginLossForward

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

Execute a SoftMarginLoss forward layer.

miopenDestroyCTCLossDescriptor

miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc)

Destroys a CTC loss function descriptor object.

MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC

@ MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC

Definition: miopen.h:5463

miopenRNNMode_t

miopenRNNMode_t

Definition: miopen.h:4067

miopenGetRNNDescriptor_V2

miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc, int *hiddenSize, int *layer, miopenDropoutDescriptor_t *dropoutDesc, miopenRNNInputMode_t *inputMode, miopenRNNDirectionMode_t *dirMode, miopenRNNMode_t *rnnMode, miopenRNNBiasMode_t *biasMode, miopenRNNAlgo_t *algoMode, miopenDataType_t *dataType)

Retrieves a RNN layer descriptor's details version 2. This version enables retrieving information of ...

miopenRNNInputMode_t

miopenRNNInputMode_t

Definition: miopen.h:4078

miopenSetRNNLayerBias

miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, void *w, const int biasID, miopenTensorDescriptor_t biasDesc, const void *layerBias)

Sets a bias for a specific layer in an RNN stack.

miopenRNNBackwardWeightsSeqTensor

miopenStatus_t miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const miopenSeqTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t hDesc, const void *hx, const miopenSeqTensorDescriptor_t yDesc, const void *y, void *dw, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, const void *reserveSpace, size_t reserveSpaceNumBytes)

Execute backward weights for recurrent layer.

miopenGetRNNParamsSize

miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenTensorDescriptor_t xDesc, size_t *numBytes, miopenDataType_t dtype)

Query the amount of parameter memory required for RNN training.

miopenGetRNNLayerBiasOffset

miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int biasID, miopenTensorDescriptor_t biasDesc, size_t *layerBiasOffset)

Gets a bias index offset for a specific layer in an RNN stack.

miopenGetRNNLayerParamOffset

miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int paramID, miopenTensorDescriptor_t paramDesc, size_t *layerParamOffset)

Gets an index offset for a specific weight matrix for a layer in the RNN stack.

miopenRNNDirectionMode_t

miopenRNNDirectionMode_t

Definition: miopen.h:4100

miopenRNNBackwardSeqData

miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const miopenSeqTensorDescriptor_t yDesc, const void *y, const void *dy, const miopenTensorDescriptor_t hDesc, const void *hx, const void *dhy, void *dhx, const miopenTensorDescriptor_t cDesc, const void *cx, const void *dcy, void *dcx, const miopenSeqTensorDescriptor_t xDesc, void *dx, const void *w, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)

Execute backward data for recurrent layer.

miopenRNNBiasMode_t

miopenRNNBiasMode_t

Definition: miopen.h:4109

miopenGetRNNLayerBias

miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, const void *w, const int biasID, miopenTensorDescriptor_t biasDesc, void *layerBias)

Gets a bias for a specific layer in an RNN stack.

miopenRNNBackwardWeights

miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t *yDesc, const void *y, const miopenTensorDescriptor_t dwDesc, void *dw, void *workSpace, size_t workSpaceNumBytes, const void *reserveSpace, size_t reserveSpaceNumBytes)

Execute backward weights for recurrent layer.

miopenGetRNNTrainingReserveSize

miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, size_t *numBytes)

Query the amount of memory required for RNN training.

miopenGetRNNLayerBiasSize

miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, const int biasID, size_t *numBytes)

Gets the number of bytes of a bias.

miopenSetRNNDescriptor

miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc, const int hsize, const int nlayers, miopenRNNInputMode_t inMode, miopenRNNDirectionMode_t direction, miopenRNNMode_t rnnMode, miopenRNNBiasMode_t biasMode, miopenRNNAlgo_t algo, miopenDataType_t dataType)

Set the details of the RNN descriptor.

miopenRNNBaseLayout_t

miopenRNNBaseLayout_t

Definition: miopen.h:4144

miopenRNNBackwardData

miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *yDesc, const void *y, const miopenTensorDescriptor_t *dyDesc, const void *dy, const miopenTensorDescriptor_t dhyDesc, const void *dhy, const miopenTensorDescriptor_t dcyDesc, const void *dcy, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t *dxDesc, void *dx, const miopenTensorDescriptor_t dhxDesc, void *dhx, const miopenTensorDescriptor_t dcxDesc, void *dcx, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)

Execute backward data for recurrent layer.

miopenGetRNNDescriptor

miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc, miopenRNNMode_t *rnnMode, miopenRNNAlgo_t *algoMode, miopenRNNInputMode_t *inputMode, miopenRNNDirectionMode_t *dirMode, miopenRNNBiasMode_t *biasMode, int *hiddenSize, int *layer)

Retrieves a RNN layer descriptor's details.

miopenRNNAlgo_t

miopenRNNAlgo_t

Definition: miopen.h:4087

miopenGetRNNTempSpaceSizes

miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenSeqTensorDescriptor_t xDesc, miopenRNNFWDMode_t fwdMode, size_t *workSpaceSize, size_t *reserveSpaceSize)

Query the amount of additional memory required for this RNN layer execution.

miopenGetRNNPaddingMode

miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t *paddingMode)

This function retrieves the RNN padding mode from the RNN descriptor.

miopenRNNForward

miopenStatus_t miopenRNNForward(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, miopenRNNFWDMode_t fwdMode, const miopenSeqTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t hDesc, const void *hx, void *hy, const miopenTensorDescriptor_t cDesc, const void *cx, void *cy, const miopenSeqTensorDescriptor_t yDesc, void *y, const void *w, size_t weightSpaceSize, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)

Execute forward training for recurrent layer.

miopenGetRNNDataSeqTensorDescriptor

miopenStatus_t miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc, miopenDataType_t *dataType, miopenRNNBaseLayout_t *layout, int *maxSequenceLen, int *batchSize, int *vectorSize, int sequenceLenArrayLimit, int *sequenceLenArray, void *paddingMarker)

Get shape of RNN seqData tensor.

miopenGetRNNInputTensorSize

miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int seqLen, miopenTensorDescriptor_t *xDesc, size_t *numBytes)

Obtain a the size in bytes of the RNN input tensor.

miopenRNNFWDMode_t

miopenRNNFWDMode_t

Definition: miopen.h:4135

miopenSetRNNLayerParam

miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, void *w, const int paramID, miopenTensorDescriptor_t paramDesc, const void *layerParam)

Sets a weight matrix for a specific layer in an RNN stack.

miopenGetRNNLayerParamSize

miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, const int paramID, size_t *numBytes)

Gets the number of bytes of a parameter matrix.

miopenCreateRNNDescriptor

miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t *rnnDesc)

Create a RNN layer Descriptor.

miopenRNNGEMMalgoMode_t

miopenRNNGEMMalgoMode_t

Definition: miopen.h:4118

miopenGetRNNLayerParam

miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int layer, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, const void *w, const int paramID, miopenTensorDescriptor_t paramDesc, void *layerParam)

Gets a weight matrix for a specific layer in an RNN stack.

miopenGetRNNWorkspaceSize

miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, size_t *numBytes)

Query the amount of memory required to execute the RNN layer.

miopenSetRNNDataSeqTensorDescriptor

miopenStatus_t miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc, miopenDataType_t dataType, miopenRNNBaseLayout_t layout, int maxSequenceLen, int batchSize, int vectorSize, const int *sequenceLenArray, void *paddingMarker)

Set shape of RNN seqData tensor.

miopenGetRNNParamsDescriptor

miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, miopenTensorDescriptor_t xDesc, miopenTensorDescriptor_t wDesc, miopenDataType_t dtype)

Obtain a weight tensor descriptor for RNNs.

miopenRNNForwardTraining

miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle, const miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t *yDesc, void *y, const miopenTensorDescriptor_t hyDesc, void *hy, const miopenTensorDescriptor_t cyDesc, void *cy, void *workSpace, size_t workSpaceNumBytes, void *reserveSpace, size_t reserveSpaceNumBytes)

Execute forward training for recurrent layer.

miopenRNNPaddingMode_t

miopenRNNPaddingMode_t

Definition: miopen.h:4126

miopenSetRNNDescriptor_V2

miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc, const int hsize, const int nlayers, miopenDropoutDescriptor_t dropoutDesc, miopenRNNInputMode_t inMode, miopenRNNDirectionMode_t direction, miopenRNNMode_t rnnMode, miopenRNNBiasMode_t biasMode, miopenRNNAlgo_t algo, miopenDataType_t dataType)

Set the details of the RNN descriptor version 2. This version enables the use of dropout in rnn.

miopenDestroyRNNDescriptor

miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc)

Destroys the tensor descriptor object.

miopenGetRNNHiddenTensorSize

miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int seqLen, miopenTensorDescriptor_t *xDesc, size_t *numBytes)

Obtain a the size in bytes of the RNN hidden tensor.

miopenSetRNNPaddingMode

miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t paddingMode)

Sets a bias for a specific layer in an RNN stack.

miopenRNNForwardInference

miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle, miopenRNNDescriptor_t rnnDesc, const int sequenceLen, const miopenTensorDescriptor_t *xDesc, const void *x, const miopenTensorDescriptor_t hxDesc, const void *hx, const miopenTensorDescriptor_t cxDesc, const void *cx, const miopenTensorDescriptor_t wDesc, const void *w, const miopenTensorDescriptor_t *yDesc, void *y, const miopenTensorDescriptor_t hyDesc, void *hy, const miopenTensorDescriptor_t cyDesc, void *cy, void *workSpace, size_t workSpaceNumBytes)

Execute forward inference for RNN layer.

miopenRNNTANH

@ miopenRNNTANH

Definition: miopen.h:4069

miopenLSTM

@ miopenLSTM

Definition: miopen.h:4070

miopenGRU

@ miopenGRU

Definition: miopen.h:4071

miopenRNNRELU

@ miopenRNNRELU

Definition: miopen.h:4068

miopenRNNlinear

@ miopenRNNlinear

Definition: miopen.h:4079

miopenRNNskip

@ miopenRNNskip

Definition: miopen.h:4080

miopenRNNbidirection

@ miopenRNNbidirection

Definition: miopen.h:4102

miopenRNNunidirection

@ miopenRNNunidirection

Definition: miopen.h:4101

miopenRNNwithBias

@ miopenRNNwithBias

Definition: miopen.h:4111

miopenRNNNoBias

@ miopenRNNNoBias

Definition: miopen.h:4110

miopenRNNDataSeqMajorPadded

@ miopenRNNDataSeqMajorPadded

Definition: miopen.h:4147

miopenRNNDataSeqMajorNotPadded

@ miopenRNNDataSeqMajorNotPadded

Definition: miopen.h:4146

miopenRNNDataBatchMajorPadded

@ miopenRNNDataBatchMajorPadded

Definition: miopen.h:4148

miopenRNNDataUnknownLayout

@ miopenRNNDataUnknownLayout

Definition: miopen.h:4145

miopenRNNroundedDynamic

@ miopenRNNroundedDynamic

Definition: miopen.h:4092

miopenRNNfundamental

@ miopenRNNfundamental

Definition: miopen.h:4090

miopenRNNdefault

@ miopenRNNdefault

Definition: miopen.h:4088

miopenRNNTraining

@ miopenRNNTraining

Definition: miopen.h:4136

miopenRNNInference

@ miopenRNNInference

Definition: miopen.h:4137

miopenRNNAlgoGEMM

@ miopenRNNAlgoGEMM

Definition: miopen.h:4119

miopenRNNIOWithPadding

@ miopenRNNIOWithPadding

Definition: miopen.h:4128

miopenRNNIONotPadded

@ miopenRNNIONotPadded

Definition: miopen.h:4127

miopenGetPReLUBackwardWorkspaceSize

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

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

miopenPReLUBackward

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

Execute a PReLU backward layer.

miopenReduceExtremeForward

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

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

miopenReduceExtremeOp_t

miopenReduceExtremeOp_t

Definition: miopen.h:6506

miopenRoPEBackward

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

Execute a rope backward layer.

miopenRoPEForward

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

Execute a rope forward layer.

miopenFusedAdam

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

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

miopenTransformersAdamW

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

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

miopenFusedAdamWithOutput

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

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

miopenTransformersAdamWWithOutput

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

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

miopenReduceTensorIndices_t

miopenReduceTensorIndices_t

Definition: miopen.h:603

miopenSetReduceTensorDescriptor

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

Initialize a ReduceTensor descriptor object.

miopenCreateReduceTensorDescriptor

miopenStatus_t miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t *reduceTensorDesc)

Creates the ReduceTensor descriptor object.

miopenReduceTensorOp_t

miopenReduceTensorOp_t

Definition: miopen.h:568

miopenIndicesType_t

miopenIndicesType_t

Definition: miopen.h:613

miopenReduceTensor

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

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

miopenGetReductionIndicesSize

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

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

miopenDestroyReduceTensorDescriptor

miopenStatus_t miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc)

Destroy the ReduceTensor descriptor object.

miopenGetReductionWorkspaceSize

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

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

miopenGetReduceTensorDescriptor

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

Query a ReduceTensor descriptor object.

miopenActivationForward

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

Execute an activation forward layer.

miopenGLUBackward

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

Execute a GLU backward layer.

miopenActivationBackward

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

Execute a activation backwards layer.

miopenActivationMode_t

miopenActivationMode_t

Definition: miopen.h:514

miopenSetActivationDescriptor

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

Sets the activation layer descriptor details.

miopenCreateActivationDescriptor

miopenStatus_t miopenCreateActivationDescriptor(miopenActivationDescriptor_t *activDesc)

Creates the Activation descriptor object.

miopenGetActivationDescriptor

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

Gets the activation layer descriptor details.

miopenGLUForward

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

Execute a GLU forward layer.

miopenDestroyActivationDescriptor

miopenStatus_t miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc)

Destroys the activation descriptor object.

miopenBatchNormalizationForwardInference

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

Execute forward inference layer for batch normalization.

miopenBatchNormalizationForwardInference_V2

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

Execute forward inference layer for batch normalization.

miopenBatchNormForwardTrainingActivation

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

Execute forward training layer for batch normalization with fused activation.

miopenBatchNormBackwardActivation

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

Execute backwards propagation layer for batch normalization with fused activation.

miopenBatchNormalizationForwardTraining

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

Execute forward training layer for batch normalization.

miopenBatchNormalizationForwardTraining_V2

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

Execute forward training layer for batch normalization.

miopenBatchNormalizationBackward_V2

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

Execute backwards propagation layer for batch normalization.

miopenBatchNormalizationBackward

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

Execute backwards propagation layer for batch normalization.

miopenBatchNormMode_t

miopenBatchNormMode_t

Definition: miopen.h:504

miopenBatchNormForwardInferenceActivation

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

Execute forward inference layer for batch normalization with fused activation.

miopenDeriveBNTensorDescriptor

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

Derive tensor for gamma and beta from input tensor descriptor.

miopenCatForward

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

Execute a cat forward layer.

miopenInitConvolutionNdDescriptor

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

Creates a N-dimensional convolution layer descriptor.

miopenConvolutionForwardImmediate

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

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

miopenConvolutionBackwardDataCompileSolution

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

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

miopenConvolutionForwardGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionForward

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

Execute a forward convolution layer.

miopenGetConvolutionGroupCount

miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)

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

miopenGetConvolutionFindMode

miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)

Reads the Find Mode attribute from the convolution descriptor.

miopenInitConvolutionDescriptor

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

Creates a 2-D convolution layer descriptor.

miopenConvAlgorithm_t

miopenConvAlgorithm_t

Definition: miopen.h:1265

miopenConvolutionBackwardData

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

Execute a backward data convolution layer.

miopenGetConvolutionAttribute

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

Get the attribute of the convolution descriptor.

miopenGetConvolutionNdForwardOutputDim

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

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

miopenConvolutionBackwardWeightsCompileSolution

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

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

miopenFindConvolutionBackwardWeightsAlgorithm

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

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

miopenGetConvolutionForwardOutputDim

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

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

miopenConvFwdAlgorithm_t

miopenConvFwdAlgorithm_t

Definition: miopen.h:1228

miopenConvolutionForwardGetWorkSpaceSize

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

Query the workspace size required for a forward convolution algorithm.

miopenCreateConvolutionDescriptor

miopenStatus_t miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t *convDesc)

Creates a convolution layer descriptor.

miopenConvolutionBackwardWeightsGetSolution

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

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

miopenGetConvolutionNdDescriptor

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

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

miopenConvBwdDataAlgorithm_t

miopenConvBwdDataAlgorithm_t

Definition: miopen.h:1251

miopenConvolutionAttrib_t

miopenConvolutionAttrib_t

Definition: miopen.h:625

miopenConvolutionBackwardWeightsGetWorkSpaceSize

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

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

miopenConvolutionBackwardWeightsImmediate

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

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

miopenFindConvolutionBackwardDataAlgorithm

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

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

miopenConvolutionBackwardDataGetSolution

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

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

miopenConvolutionForwardBias

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

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

miopenConvolutionMode_t

miopenConvolutionMode_t

Definition: miopen.h:429

miopenSetConvolutionAttribute

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

Set the attribute of the convolution descriptor.

miopenConvolutionBackwardDataImmediate

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

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

miopenSetTransposeConvNdOutputPadding

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

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

miopenSetConvolutionFindMode

miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t findMode)

Sets the Find Mode attribute in the convolution descriptor.

miopenSetTransposeConvOutputPadding

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

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

miopenConvolutionFindMode_t

miopenConvolutionFindMode_t

Definition: miopen.h:651

miopenGetConvolutionSpatialDim

miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc, int *spatialDim)

Retrieves the spatial dimension of a convolution layer descriptor.

miopenConvBwdWeightsAlgorithm_t

miopenConvBwdWeightsAlgorithm_t

Definition: miopen.h:1240

miopenConvolutionForwardCompileSolution

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

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

miopenConvolutionBackwardDataGetSolutionCount

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

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

miopenConvolutionBackwardWeights

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

Execute a backward weights convolution layer.

miopenConvolutionBackwardDataGetWorkSpaceSize

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

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

miopenFindConvolutionForwardAlgorithm

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

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

miopenDestroyConvolutionDescriptor

miopenStatus_t miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc)

Destroys the tensor descriptor object.

miopenConvolutionBackwardWeightsGetSolutionCount

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

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

miopenSetConvolutionGroupCount

miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int groupCount)

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

miopenConvolutionBackwardWeightsGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionForwardGetSolution

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

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

miopenGetConvolutionDescriptor

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

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

miopenConvolutionForwardGetSolutionCount

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

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

miopenConvolutionBackwardDataGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionBackwardBias

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

Calculates the gradient with respect to the bias.

miopenConvolutionAlgoDirect

@ miopenConvolutionAlgoDirect

Definition: miopen.h:1267

miopenConvolutionAlgoWinograd

@ miopenConvolutionAlgoWinograd

Definition: miopen.h:1269

miopenConvolutionAlgoFFT

@ miopenConvolutionAlgoFFT

Definition: miopen.h:1268

miopenConvolutionAlgoImplicitGEMM

@ miopenConvolutionAlgoImplicitGEMM

Definition: miopen.h:1270

miopenConvolutionAlgoGEMM

@ miopenConvolutionAlgoGEMM

Definition: miopen.h:1266

miopenConvolutionFwdAlgoFFT

@ miopenConvolutionFwdAlgoFFT

Definition: miopen.h:1231

miopenConvolutionFwdAlgoImplicitGEMM

@ miopenConvolutionFwdAlgoImplicitGEMM

Definition: miopen.h:1233

miopenConvolutionFwdAlgoGEMM

@ miopenConvolutionFwdAlgoGEMM

Definition: miopen.h:1229

miopenConvolutionFwdAlgoWinograd

@ miopenConvolutionFwdAlgoWinograd

Definition: miopen.h:1232

miopenConvolutionFwdAlgoDirect

@ miopenConvolutionFwdAlgoDirect

Definition: miopen.h:1230

miopenTransposeBwdDataAlgoGEMM

@ miopenTransposeBwdDataAlgoGEMM

Definition: miopen.h:1256

miopenConvolutionBwdDataAlgoDirect

@ miopenConvolutionBwdDataAlgoDirect

Definition: miopen.h:1253

miopenConvolutionBwdDataAlgoGEMM

@ miopenConvolutionBwdDataAlgoGEMM

Definition: miopen.h:1252

miopenConvolutionBwdDataAlgoFFT

@ miopenConvolutionBwdDataAlgoFFT

Definition: miopen.h:1254

miopenConvolutionBwdDataAlgoWinograd

@ miopenConvolutionBwdDataAlgoWinograd

Definition: miopen.h:1255

miopenConvolutionBwdDataAlgoImplicitGEMM

@ miopenConvolutionBwdDataAlgoImplicitGEMM

Definition: miopen.h:1258

miopenConvolutionBwdWeightsAlgoGEMM

@ miopenConvolutionBwdWeightsAlgoGEMM

Definition: miopen.h:1241

miopenConvolutionBwdWeightsAlgoWinograd

@ miopenConvolutionBwdWeightsAlgoWinograd

Definition: miopen.h:1243

miopenConvolutionBwdWeightsAlgoDirect

@ miopenConvolutionBwdWeightsAlgoDirect

Definition: miopen.h:1242

miopenConvolutionBwdWeightsAlgoImplicitGEMM

@ miopenConvolutionBwdWeightsAlgoImplicitGEMM

Definition: miopen.h:1244

miopenDestroyDropoutDescriptor

miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)

Destroys the dropout descriptor object.

miopenRNGType_t

miopenRNGType_t

Definition: miopen.h:5582

miopenDropoutGetStatesSize

miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle, size_t *stateSizeInBytes)

Query the amount of memory required to store the states of the random number generators.

miopenDropoutGetReserveSpaceSize

miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc, size_t *reserveSpaceSizeInBytes)

Query the amount of memory required to run dropout.

miopenDropoutForward

miopenStatus_t miopenDropoutForward(miopenHandle_t handle, const miopenDropoutDescriptor_t dropoutDesc, const miopenTensorDescriptor_t noise_shape, const miopenTensorDescriptor_t xDesc, const void *x, const miopenTensorDescriptor_t yDesc, void *y, void *reserveSpace, size_t reserveSpaceSizeInBytes)

Execute forward dropout operation.

miopenGetDropoutDescriptor

miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float *dropout, void **states, unsigned long long *seed, bool *use_mask, bool *state_evo, miopenRNGType_t *rng_mode)

Get the details of the dropout descriptor.

miopenCreateDropoutDescriptor

miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t *dropoutDesc)

Creates the dropout descriptor object.

miopenDropoutBackward

miopenStatus_t miopenDropoutBackward(miopenHandle_t handle, const miopenDropoutDescriptor_t dropoutDesc, const miopenTensorDescriptor_t noise_shape, const miopenTensorDescriptor_t dyDesc, const void *dy, const miopenTensorDescriptor_t dxDesc, void *dx, void *reserveSpace, size_t reserveSpaceSizeInBytes)

Execute backward dropout operation.

miopenRestoreDropoutDescriptor

miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float dropout, void *states, size_t stateSizeInBytes, unsigned long long seed, bool use_mask, bool state_evo, miopenRNGType_t rng_mode)

Restore the dropout descriptor to a saved state.

miopenSetDropoutDescriptor

miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc, miopenHandle_t handle, float dropout, void *states, size_t stateSizeInBytes, unsigned long long seed, bool use_mask, bool state_evo, miopenRNGType_t rng_mode)

Initialize the dropout descriptor.

MIOPEN_RNG_PSEUDO_XORWOW

@ MIOPEN_RNG_PSEUDO_XORWOW

Definition: miopen.h:5583

miopenFindResultsOrder_t

miopenFindResultsOrder_t

Definition: miopen.h:6013

miopenGetSolutionSolverId

miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution, uint64_t *solverId)

Reads id of the solver referred by the solution.

miopenSetSoftmaxDescriptor

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

Sets the softmax descriptor details.

miopenGetSolutionTime

miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float *time)

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

miopenGetMhaDescriptor

miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float *scale)

Gets the Mha descriptor details.

miopenMhaMask_t

miopenMhaMask_t

Initializes a problem object describing a Mha operation.

Definition: miopen.h:6041

miopenSetMhaDescriptor

miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale)

Sets the Mha descriptor details.

miopenSetFindOptionWorkspaceLimit

miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options, size_t value)

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

miopenSetFindOptionPreallocatedTensor

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

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

miopenCreateSoftmaxProblem

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

Initializes a problem object describing a softmax operation.

miopenDestroyFindOptions

miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options)

Destroys miopenFindOptions object.

miopenSetFindOptionAttachBinaries

miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options, unsigned attach)

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

miopenFuseProblems

miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2)

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

miopenGetSolutionSize

miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t *size)

Reads the expected size of a solution.

miopenTensorArgumentId_t

miopenTensorArgumentId_t

Definition: miopen.h:5932

miopenFindSolutions

miopenStatus_t miopenFindSolutions(miopenHandle_t handle, miopenProblem_t problem, miopenFindOptions_t options, miopenSolution_t *solutions, size_t *numSolutions, size_t maxSolutions)

Finds solutions to a problem by running different applicable solutions. Memory is automatically alloc...

miopenSetFindOptionTuning

miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value)

Sets the tuning find option. Default value is zero.

miopenGetSolutionWorkspaceSize

miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution, size_t *workspaceSize)

Reads the amount of workspace required to exectute the solution.

miopenSetFindOptionResultsOrder

miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options, miopenFindResultsOrder_t value)

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

miopenRunSolution

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

Runs the solution using the passed in buffers.

miopenCreateMhaProblem

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

miopenProblemDirection_t

miopenProblemDirection_t

Definition: miopen.h:5919

miopenCreateBatchnormProblem

miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t *problem, miopenBatchNormMode_t mode, bool runningMeanVariance, miopenProblemDirection_t direction)

Initializes a problem object describing an activation operation.

miopenCreateMhaDescriptor

miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t *mhaDesc)

Creates the mha descriptor object.

miopenDestroySolution

miopenStatus_t miopenDestroySolution(miopenSolution_t solution)

Destroys solution object.

miopenLoadSolution

miopenStatus_t miopenLoadSolution(miopenSolution_t *solution, const char *data, size_t size)

Loads solution object from binary data.

miopenSaveSolution

miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char *data)

Saves a solution object as binary data.

miopenGetSolverIdConvAlgorithm

miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId, miopenConvAlgorithm_t *result)

Gets the convolution algorithm implemented by a solver.

miopenSetFindOptionPreallocatedWorkspace

miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options, void *buffer, size_t size)

Attaches the preallocated workspace to find options. Allocated by the library by default.

miopenCreateActivationProblem

miopenStatus_t miopenCreateActivationProblem(miopenProblem_t *problem, miopenActivationDescriptor_t operatorDesc, miopenProblemDirection_t direction)

Initializes a problem object describing an activation operation.

miopenDestroyProblem

miopenStatus_t miopenDestroyProblem(miopenProblem_t problem)

Destroys a problem object.

miopenCreateFindOptions

miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t *options)

Initializes miopenFindOptions object.

miopenGetSoftmaxDescriptor

miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc, float *alpha, float *beta, miopenSoftmaxAlgorithm_t *algorithm, miopenSoftmaxMode_t *mode)

Gets the softmax layer descriptor details.

miopenCreateConvProblem

miopenStatus_t miopenCreateConvProblem(miopenProblem_t *problem, miopenConvolutionDescriptor_t operatorDesc, miopenProblemDirection_t direction)

Initializes a problem object describing a convolution operation.

miopenCreateBiasProblem

miopenStatus_t miopenCreateBiasProblem(miopenProblem_t *problem, miopenProblemDirection_t direction)

Initializes a problem object describing an bias operation.

miopenSetProblemTensorDescriptor

miopenStatus_t miopenSetProblemTensorDescriptor(miopenProblem_t problem, miopenTensorArgumentId_t id, const miopenTensorDescriptor_t descriptor)

Sets a tensor descriptor for the specified argument.

miopenCreateSoftmaxDescriptor

miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t *softmaxDesc)

Creates the Softmax descriptor object.

miopenFindResultsOrderByWorkspaceSize

@ miopenFindResultsOrderByWorkspaceSize

Definition: miopen.h:6015

miopenFindResultsOrderByTime

@ miopenFindResultsOrderByTime

Definition: miopen.h:6014

miopenMhaMaskCausal

@ miopenMhaMaskCausal

Definition: miopen.h:6043

miopenMhaMaskNone

@ miopenMhaMaskNone

Definition: miopen.h:6042

miopenTensorMhaDescaleS

@ miopenTensorMhaDescaleS

Definition: miopen.h:5944

miopenTensorMhaO

@ miopenTensorMhaO

Definition: miopen.h:5950

miopenTensorMhaAmaxDV

@ miopenTensorMhaAmaxDV

Definition: miopen.h:5968

miopenTensorBatchnormScaleDiff

@ miopenTensorBatchnormScaleDiff

Definition: miopen.h:5991

miopenTensorMhaMask

@ miopenTensorMhaMask

Definition: miopen.h:6002

miopenTensorMhaDescaleDS

@ miopenTensorMhaDescaleDS

Definition: miopen.h:5958

miopenTensorMhaDropoutSeed

@ miopenTensorMhaDropoutSeed

Definition: miopen.h:5948

miopenTensorBatchnormSavedMean

@ miopenTensorBatchnormSavedMean

Definition: miopen.h:5988

miopenTensorActivationDY

@ miopenTensorActivationDY

Definition: miopen.h:5976

miopenTensorBatchnormDX

@ miopenTensorBatchnormDX

Definition: miopen.h:5996

miopenTensorMhaDescaleV

@ miopenTensorMhaDescaleV

Definition: miopen.h:5943

miopenTensorMhaK

@ miopenTensorMhaK

Definition: miopen.h:5938

miopenTensorConvolutionX

@ miopenTensorConvolutionX

Definition: miopen.h:5934

miopenTensorMhaAmaxDK

@ miopenTensorMhaAmaxDK

Definition: miopen.h:5967

miopenTensorMhaScaleDS

@ miopenTensorMhaScaleDS

Definition: miopen.h:5959

miopenTensorBatchnormBias

@ miopenTensorBatchnormBias

Definition: miopen.h:5994

miopenTensorMhaM

@ miopenTensorMhaM

Definition: miopen.h:5953

miopenTensorBatchnormRunningMean

@ miopenTensorBatchnormRunningMean

Definition: miopen.h:5986

miopenTensorMhaDropoutProbability

@ miopenTensorMhaDropoutProbability

Definition: miopen.h:5947

miopenTensorSoftmaxY

@ miopenTensorSoftmaxY

Definition: miopen.h:5981

miopenTensorSoftmaxDY

@ miopenTensorSoftmaxDY

Definition: miopen.h:5983

miopenTensorMhaDescaleO

@ miopenTensorMhaDescaleO

Definition: miopen.h:5956

miopenTensorMhaScaleO

@ miopenTensorMhaScaleO

Definition: miopen.h:5946

miopenScalarBatchnormExpAvgFactor

@ miopenScalarBatchnormExpAvgFactor

Definition: miopen.h:6004

miopenTensorBatchnormScale

@ miopenTensorBatchnormScale

Definition: miopen.h:5990

miopenTensorBatchnormRunningVariance

@ miopenTensorBatchnormRunningVariance

Definition: miopen.h:5987

miopenTensorActivationDX

@ miopenTensorActivationDX

Definition: miopen.h:5975

miopenTensorMhaScaleDK

@ miopenTensorMhaScaleDK

Definition: miopen.h:5961

miopenTensorMhaV

@ miopenTensorMhaV

Definition: miopen.h:5940

miopenTensorMhaAmaxS

@ miopenTensorMhaAmaxS

Definition: miopen.h:5952

miopenTensorBatchnormBiasDiff

@ miopenTensorBatchnormBiasDiff

Definition: miopen.h:5995

miopenTensorBatchnormSavedVariance

@ miopenTensorBatchnormSavedVariance

Definition: miopen.h:5989

miopenTensorActivationX

@ miopenTensorActivationX

Definition: miopen.h:5973

miopenTensorMhaScaleDV

@ miopenTensorMhaScaleDV

Definition: miopen.h:5962

miopenTensorMhaAmaxO

@ miopenTensorMhaAmaxO

Definition: miopen.h:5951

miopenScalarBatchnormEpsilon

@ miopenScalarBatchnormEpsilon

Definition: miopen.h:6005

miopenTensorMhaScaleDQ

@ miopenTensorMhaScaleDQ

Definition: miopen.h:5960

miopenTensorSoftmaxDX

@ miopenTensorSoftmaxDX

Definition: miopen.h:5982

miopenTensorMhaAmaxDS

@ miopenTensorMhaAmaxDS

Definition: miopen.h:5969

miopenTensorMhaDV

@ miopenTensorMhaDV

Definition: miopen.h:5965

miopenTensorMhaQ

@ miopenTensorMhaQ

Definition: miopen.h:5939

miopenTensorMhaAmaxDQ

@ miopenTensorMhaAmaxDQ

Definition: miopen.h:5966

miopenTensorConvolutionY

@ miopenTensorConvolutionY

Definition: miopen.h:5936

miopenTensorBatchnormEstimatedMean

@ miopenTensorBatchnormEstimatedMean

Definition: miopen.h:5992

miopenTensorBatchnormDY

@ miopenTensorBatchnormDY

Definition: miopen.h:5997

miopenTensorMhaZInv

@ miopenTensorMhaZInv

Definition: miopen.h:5954

miopenTensorMhaDescaleQ

@ miopenTensorMhaDescaleQ

Definition: miopen.h:5942

miopenTensorMhaBias

@ miopenTensorMhaBias

Definition: miopen.h:5970

miopenTensorBatchnormEstimatedVariance

@ miopenTensorBatchnormEstimatedVariance

Definition: miopen.h:5993

miopenTensorArgumentIsScalar

@ miopenTensorArgumentIsScalar

Definition: miopen.h:6000

miopenTensorArgumentIdInvalid

@ miopenTensorArgumentIdInvalid

Definition: miopen.h:5933

miopenTensorMhaDO

@ miopenTensorMhaDO

Definition: miopen.h:5955

miopenTensorMhaDescaleDO

@ miopenTensorMhaDescaleDO

Definition: miopen.h:5957

miopenTensorConvolutionW

@ miopenTensorConvolutionW

Definition: miopen.h:5935

miopenTensorMhaDescaleK

@ miopenTensorMhaDescaleK

Definition: miopen.h:5941

miopenTensorMhaDropoutOffset

@ miopenTensorMhaDropoutOffset

Definition: miopen.h:5949

miopenTensorBiasY

@ miopenTensorBiasY

Definition: miopen.h:5978

miopenTensorMhaDQ

@ miopenTensorMhaDQ

Definition: miopen.h:5963

miopenTensorSoftmaxX

@ miopenTensorSoftmaxX

Definition: miopen.h:5980

miopenTensorBatchnormY

@ miopenTensorBatchnormY

Definition: miopen.h:5985

miopenTensorMhaScaleS

@ miopenTensorMhaScaleS

Definition: miopen.h:5945

miopenTensorBias

@ miopenTensorBias

Definition: miopen.h:5979

miopenTensorActivationY

@ miopenTensorActivationY

Definition: miopen.h:5974

miopenTensorBatchnormX

@ miopenTensorBatchnormX

Definition: miopen.h:5984

miopenTensorBiasX

@ miopenTensorBiasX

Definition: miopen.h:5977

miopenTensorMhaDK

@ miopenTensorMhaDK

Definition: miopen.h:5964

miopenProblemDirectionBackwardWeights

@ miopenProblemDirectionBackwardWeights

Definition: miopen.h:5922

miopenProblemDirectionInference

@ miopenProblemDirectionInference

Definition: miopen.h:5924

miopenProblemDirectionForward

@ miopenProblemDirectionForward

Definition: miopen.h:5920

miopenProblemDirectionBackward

@ miopenProblemDirectionBackward

Definition: miopen.h:5921

miopenGetGetitemWorkspaceSize

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

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

miopenGetitemBackward

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

Execute a getitem backward layer.

miopenGroupNormForward

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

Execute a groupnorm forward layer.

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

miopenGetTuningPolicy

miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t *value)

Get tuning policy from a handle.

miopenDeallocatorFunction

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

Custom deallocator function.

Definition: miopen.h:158

miopenGetStream

miopenStatus_t miopenGetStream(miopenHandle_t handle, miopenAcceleratorQueue_t *streamID)

Get the previously created accelerator command queue.

miopenEnableProfiling

miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable)

Enable profiling to retrieve kernel time.

miopenGetVersion

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

Method to return version of MIOpen.

miopenSetTuningPolicy

miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle, miopenTuningPolicy_t newValue)

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

miopenStatus_t

miopenStatus_t

Definition: miopen.h:109

miopenSetAllocator

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

Set allocator for previously created miopenHandle.

miopenF8RoundingMode_t

miopenF8RoundingMode_t

Definition: miopen.h:125

miopenAllocatorFunction

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

Custom allocator function.

Definition: miopen.h:148

miopenGetErrorString

const char * miopenGetErrorString(miopenStatus_t error)

Get character string for an error code.

miopenCreate

miopenStatus_t miopenCreate(miopenHandle_t *handle)

Method to create the MIOpen handle object.

miopenGetKernelTime

miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float *time)

Get time for last kernel launched.

miopenSetStream

miopenStatus_t miopenSetStream(miopenHandle_t handle, miopenAcceleratorQueue_t streamID)

Set accelerator command queue previously created.

miopenStatusUnsupportedOp

@ miopenStatusUnsupportedOp

Definition: miopen.h:118

miopenStatusGpuOperationsSkipped

@ miopenStatusGpuOperationsSkipped

Definition: miopen.h:119

miopenStatusUnknownError

@ miopenStatusUnknownError

Definition: miopen.h:117

miopenStatusSuccess

@ miopenStatusSuccess

Definition: miopen.h:110

miopenStatusVersionMismatch

@ miopenStatusVersionMismatch

Definition: miopen.h:120

miopenStatusAllocFailed

@ miopenStatusAllocFailed

Definition: miopen.h:114

miopenStatusNotImplemented

@ miopenStatusNotImplemented

Definition: miopen.h:116

miopenStatusBadParm

@ miopenStatusBadParm

Definition: miopen.h:113

miopenStatusNotInitialized

@ miopenStatusNotInitialized

Definition: miopen.h:111

miopenStatusInternalError

@ miopenStatusInternalError

Definition: miopen.h:115

miopenStatusInvalidValue

@ miopenStatusInvalidValue

Definition: miopen.h:112

miopenF8RoundingModeStandard

@ miopenF8RoundingModeStandard

Definition: miopen.h:126

miopenF8RoundingModeStochastic

@ miopenF8RoundingModeStochastic

Definition: miopen.h:127

miopenKthvalueForward

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

Execute a Kthvalue forward layer.

miopenLayerNormForward

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

Execute a layernorm forward layer.

miopenT5LayerNormBackward

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

Execute a T5layernorm backward layer.

miopenLayerNormBackward

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

Execute a layernorm backward layer.

miopenT5LayerNormForward

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

Execute a T5layernorm forward layer.

miopenNormMode_t

miopenNormMode_t

Definition: miopen.h:485

miopenGetLayerNormBackwardWorkspaceSize

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

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

miopenGetT5LayerNormBackwardWorkspaceSize

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

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

miopenAddLayerNormForward

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

Execute a add and layernorm forward layer.

miopenSet2dPoolingDescriptor

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

Sets a 2-D pooling layer descriptor details.

miopenSetPoolingWorkSpaceIndexMode

miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index)

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

miopenGetPoolingForwardOutputDim

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

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

miopenPoolingGetWorkSpaceSize

miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc, size_t *workSpaceSize)

Get the amount of GPU memory required for pooling.

miopenSetNdPoolingDescriptor

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

Set details of a N-D pooling layer descriptor.

miopenPoolingForward

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

Execute a forward pooling layer.

miopenPoolingMode_t

miopenPoolingMode_t

Definition: miopen.h:452

miopenPoolingGetWorkSpaceSizeV2

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

Get the amount of GPU memory required for pooling.

miopenGetPoolingWorkSpaceIndexMode

miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t *workspace_index)

Get workspace index mode for pooling layer.

miopenIndexType_t

miopenIndexType_t

Definition: miopen.h:405

miopenGetPoolingIndexType

miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t *index_type)

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

miopenPoolingWorkspaceIndexMode_t

miopenPoolingWorkspaceIndexMode_t

Definition: miopen.h:465

miopenGetPoolingNdForwardOutputDim

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

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

miopenGetNdPoolingDescriptor

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

Get details of a N-D pooling layer descriptor.

miopenCreatePoolingDescriptor

miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t *poolDesc)

Creates a pooling layer descriptor.

miopenSetPoolingIndexType

miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc, miopenIndexType_t index_type)

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

miopenGet2dPoolingDescriptor

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

Gets a 2-D pooling layer descriptor details.

miopenDestroyPoolingDescriptor

miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc)

Destroys the pooling descriptor object.

miopenPoolingBackward

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

Execute a backward pooling layer.

miopenReduceCalculationForward

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

Execute a reducecalculation forward layer.

miopenReduceCalculationOp_t

miopenReduceCalculationOp_t

Definition: miopen.h:6446

miopenGetReduceCalculationWorkspaceSize

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

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

MIOPEN_REDUCE_CALCULATION_PROD

@ MIOPEN_REDUCE_CALCULATION_PROD

Definition: miopen.h:6447

MIOPEN_REDUCE_CALCULATION_SUM

@ MIOPEN_REDUCE_CALCULATION_SUM

Definition: miopen.h:6449

miopenSoftmaxBackward_V2

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

Execute a softmax backwards layer with expanded modes and algorithms.

miopenSoftmaxForward

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

Execute a softmax forward layer.

miopenSoftmaxForward_V2

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

Execute a softmax forward layer with expanded modes and algorithms.

miopenSoftmaxBackward

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

Execute a softmax backwards layer.

miopenSoftmaxMode_t

miopenSoftmaxMode_t

Definition: miopen.h:548

miopenSoftmaxAlgorithm_t

miopenSoftmaxAlgorithm_t

Definition: miopen.h:537

miopenDestroySeqTensorDescriptor

miopenStatus_t miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc)

Destroys the sequence data tensor descriptor.

miopenGetTensorDescriptor

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

Get the details of the N-dimensional tensor descriptor.

miopenSetNdTensorDescriptorWithLayout

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

Set shape of ND tensor with specific layout.

miopenSetTensor

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

Fills a tensor with a single value.

miopenOpTensor

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

Execute element-wise tensor operations.

miopenGetTensorNumBytes

miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc, size_t *numBytes)

Returns number of bytes associated with tensor descriptor.

miopenGet4dTensorDescriptor

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

Get the details of the tensor descriptor.

miopenTensorLayout_t

miopenTensorLayout_t

Definition: miopen.h:388

miopenTransformTensor

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

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

miopenCreateTensorDescriptor

miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor.

miopenSetTensorDescriptorV2

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

Set shape of N-dimensional tensor.

miopenScaleTensor

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

Scales all elements in a tensor by a single value.

miopenSetTensorCastType

miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc, miopenDataType_t cast_type)

Set the tensor cast type.

miopenSet4dTensorDescriptor

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

Set shape of 4D tensor.

miopenSet4dTensorDescriptorEx

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

Set shape and stride of 4D tensor.

miopenDataType_t

miopenDataType_t

Definition: miopen.h:368

miopenCreateSeqTensorDescriptor

miopenStatus_t miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t *tensorDesc)

Create a Tensor Descriptor for sequence data.

miopenTensorOp_t

miopenTensorOp_t

Definition: miopen.h:417

miopenGetTensorDescriptorSize

miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc, int *size)

Set shape of N-dimensional tensor.

miopenDestroyTensorDescriptor

miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc)

Destroys the tensor descriptor.

miopenSetTensorDescriptor

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

Set shape of N-dimensional tensor.

miopenPaddingMode_t

miopenPaddingMode_t

Definition: miopen.h:441

miopenPaddingDefault

@ miopenPaddingDefault

Definition: miopen.h:442

miopenPaddingSame

@ miopenPaddingSame

Definition: miopen.h:443

miopenPaddingValid

@ miopenPaddingValid

Definition: miopen.h:444

miopenReduceCalculationNanPropagation_t

miopenReduceCalculationNanPropagation_t

Definition: miopen.h:6430

MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

Definition: miopen.h:6432

MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

Definition: miopen.h:6431

MIOPEN_DECLARE_OBJECT

#define MIOPEN_DECLARE_OBJECT(name)

Definition: miopen.h:79

miopenNanPropagation_t

miopenNanPropagation_t

Definition: miopen.h:593

MIOPEN_PROPAGATE_NAN

@ MIOPEN_PROPAGATE_NAN

Definition: miopen.h:595

MIOPEN_NOT_PROPAGATE_NAN

@ MIOPEN_NOT_PROPAGATE_NAN

Definition: miopen.h:594

MIOPEN_LOSS_REDUCTION_MEAN

@ MIOPEN_LOSS_REDUCTION_MEAN

Definition: miopen.h:8350

MIOPEN_LOSS_REDUCTION_SUM

@ MIOPEN_LOSS_REDUCTION_SUM

Definition: miopen.h:8349

MIOPEN_LOSS_REDUCTION_NONE

@ MIOPEN_LOSS_REDUCTION_NONE

Definition: miopen.h:8348

miopenTuningPolicyDbClean

@ miopenTuningPolicyDbClean

Definition: miopen.h:8537

miopenTuningPolicyDbUpdate

@ miopenTuningPolicyDbUpdate

Definition: miopen.h:8533

miopenTuningPolicyNone

@ miopenTuningPolicyNone

Definition: miopen.h:8532

miopenTuningPolicySearch

@ miopenTuningPolicySearch

Definition: miopen.h:8534

miopenTuningPolicySearchDbUpdate

@ miopenTuningPolicySearchDbUpdate

Definition: miopen.h:8536

miopenPoolingAverage

@ miopenPoolingAverage

Definition: miopen.h:454

miopenPoolingAverageInclusive

@ miopenPoolingAverageInclusive

Definition: miopen.h:455

miopenPoolingMax

@ miopenPoolingMax

Definition: miopen.h:453

miopenTensorCHWN

@ miopenTensorCHWN

Definition: miopen.h:391

miopenTensorNHWC

@ miopenTensorNHWC

Definition: miopen.h:390

miopenTensorNDHWC

@ miopenTensorNDHWC

Definition: miopen.h:397

miopenTensorNCHW

@ miopenTensorNCHW

Definition: miopen.h:389

miopenTensorCHWNc4

@ miopenTensorCHWNc4

Definition: miopen.h:394

miopenTensorNCHWc8

@ miopenTensorNCHWc8

Definition: miopen.h:393

miopenTensorNCDHW

@ miopenTensorNCDHW

Definition: miopen.h:396

miopenTensorCHWNc8

@ miopenTensorCHWNc8

Definition: miopen.h:395

miopenTensorNCHWc4

@ miopenTensorNCHWc4

Definition: miopen.h:392

MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

@ MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES

Definition: miopen.h:605

MIOPEN_REDUCE_TENSOR_NO_INDICES

@ MIOPEN_REDUCE_TENSOR_NO_INDICES

Definition: miopen.h:604

miopenActivationLEAKYRELU

@ miopenActivationLEAKYRELU

Definition: miopen.h:524

miopenActivationPASTHRU

@ miopenActivationPASTHRU

Definition: miopen.h:515

miopenActivationABS

@ miopenActivationABS

Definition: miopen.h:520

miopenActivationLOGISTIC

@ miopenActivationLOGISTIC

Definition: miopen.h:516

miopenActivationCLIPPEDRELU

@ miopenActivationCLIPPEDRELU

Definition: miopen.h:522

miopenActivationRELU

@ miopenActivationRELU

Definition: miopen.h:518

miopenActivationPOWER

@ miopenActivationPOWER

Definition: miopen.h:521

miopenActivationELU

@ miopenActivationELU

Definition: miopen.h:526

miopenActivationCLAMP

@ miopenActivationCLAMP

Definition: miopen.h:529

miopenActivationSOFTRELU

@ miopenActivationSOFTRELU

Definition: miopen.h:519

miopenActivationTANH

@ miopenActivationTANH

Definition: miopen.h:517

MIOPEN_REDUCE_TENSOR_MUL

@ MIOPEN_REDUCE_TENSOR_MUL

Definition: miopen.h:570

MIOPEN_REDUCE_TENSOR_MAX

@ MIOPEN_REDUCE_TENSOR_MAX

Definition: miopen.h:574

MIOPEN_REDUCE_TENSOR_AVG

@ MIOPEN_REDUCE_TENSOR_AVG

Definition: miopen.h:578

MIOPEN_REDUCE_TENSOR_NORM1

@ MIOPEN_REDUCE_TENSOR_NORM1

Definition: miopen.h:580

MIOPEN_REDUCE_TENSOR_AMAX

@ MIOPEN_REDUCE_TENSOR_AMAX

Definition: miopen.h:576

MIOPEN_REDUCE_TENSOR_MIN

@ MIOPEN_REDUCE_TENSOR_MIN

Definition: miopen.h:572

MIOPEN_REDUCE_TENSOR_ADD

@ MIOPEN_REDUCE_TENSOR_ADD

Definition: miopen.h:569

MIOPEN_REDUCE_TENSOR_NORM2

@ MIOPEN_REDUCE_TENSOR_NORM2

Definition: miopen.h:582

MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

@ MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC

Definition: miopen.h:630

MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

@ MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE

Definition: miopen.h:634

MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

@ MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL

Definition: miopen.h:626

miopenIndexUint16

@ miopenIndexUint16

Definition: miopen.h:407

miopenIndexUint64

@ miopenIndexUint64

Definition: miopen.h:409

miopenIndexUint32

@ miopenIndexUint32

Definition: miopen.h:408

miopenIndexUint8

@ miopenIndexUint8

Definition: miopen.h:406

miopenFloat

@ miopenFloat

Definition: miopen.h:370

miopenBFloat8_fnuz

@ miopenBFloat8_fnuz

Definition: miopen.h:378

miopenBFloat16

@ miopenBFloat16

Definition: miopen.h:374

miopenInt8

@ miopenInt8

Definition: miopen.h:372

miopenInt32

@ miopenInt32

Definition: miopen.h:371

miopenHalf

@ miopenHalf

Definition: miopen.h:369

miopenInt64

@ miopenInt64

Definition: miopen.h:379

miopenDouble

@ miopenDouble

Definition: miopen.h:376

miopenFloat8_fnuz

@ miopenFloat8_fnuz

Definition: miopen.h:377

MIOPEN_8BIT_INDICES

@ MIOPEN_8BIT_INDICES

Definition: miopen.h:617

MIOPEN_32BIT_INDICES

@ MIOPEN_32BIT_INDICES

Definition: miopen.h:614

MIOPEN_16BIT_INDICES

@ MIOPEN_16BIT_INDICES

Definition: miopen.h:616

MIOPEN_64BIT_INDICES

@ MIOPEN_64BIT_INDICES

Definition: miopen.h:615

miopenPoolingWorkspaceIndexImage

@ miopenPoolingWorkspaceIndexImage

Definition: miopen.h:467

miopenPoolingWorkspaceIndexMask

@ miopenPoolingWorkspaceIndexMask

Definition: miopen.h:466

miopenDepthwise

@ miopenDepthwise

Definition: miopen.h:433

miopenGroupConv

@ miopenGroupConv

Definition: miopen.h:432

miopenTranspose

@ miopenTranspose

Definition: miopen.h:431

miopenConvolution

@ miopenConvolution

Definition: miopen.h:430

MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

@ MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD

Definition: miopen.h:489

MIOPEN_WEIGHT_BIAS

@ MIOPEN_WEIGHT_BIAS

Definition: miopen.h:487

MIOPEN_ELEMENTWISE_AFFINE

@ MIOPEN_ELEMENTWISE_AFFINE

Definition: miopen.h:486

MIOPEN_WEIGHT_BIAS_T5

@ MIOPEN_WEIGHT_BIAS_T5

Definition: miopen.h:495

MIOPEN_ELEMENTWISE_AFFINE_T5

@ MIOPEN_ELEMENTWISE_AFFINE_T5

Definition: miopen.h:493

MIOPEN_WEIGHT_BIAS_FUSED_ADD

@ MIOPEN_WEIGHT_BIAS_FUSED_ADD

Definition: miopen.h:491

MIOPEN_REDUCE_EXTREME_ARGMAX

@ MIOPEN_REDUCE_EXTREME_ARGMAX

Definition: miopen.h:6509

MIOPEN_REDUCE_EXTREME_MIN

@ MIOPEN_REDUCE_EXTREME_MIN

Definition: miopen.h:6511

MIOPEN_REDUCE_EXTREME_MAX

@ MIOPEN_REDUCE_EXTREME_MAX

Definition: miopen.h:6513

MIOPEN_REDUCE_EXTREME_ARGMIN

@ MIOPEN_REDUCE_EXTREME_ARGMIN

Definition: miopen.h:6507

miopenTensorOpMin

@ miopenTensorOpMin

Definition: miopen.h:420

miopenTensorOpAdd

@ miopenTensorOpAdd

Definition: miopen.h:418

miopenTensorOpMul

@ miopenTensorOpMul

Definition: miopen.h:419

miopenTensorOpMax

@ miopenTensorOpMax

Definition: miopen.h:421

miopenBNSpatial

@ miopenBNSpatial

Definition: miopen.h:506

miopenBNPerActivation

@ miopenBNPerActivation

Definition: miopen.h:505

miopenConvolutionFindModeDynamicHybrid

@ miopenConvolutionFindModeDynamicHybrid

Definition: miopen.h:663

miopenConvolutionFindModeDefault

@ miopenConvolutionFindModeDefault

Definition: miopen.h:670

miopenConvolutionFindModeTrustVerifyFull

@ miopenConvolutionFindModeTrustVerifyFull

Definition: miopen.h:669

miopenConvolutionFindModeTrustVerify

@ miopenConvolutionFindModeTrustVerify

Definition: miopen.h:668

miopenConvolutionFindModeHybrid

@ miopenConvolutionFindModeHybrid

Definition: miopen.h:658

miopenConvolutionFindModeFast

@ miopenConvolutionFindModeFast

Definition: miopen.h:654

miopenConvolutionFindModeNormal

@ miopenConvolutionFindModeNormal

Definition: miopen.h:652

miopenLRNWithinChannel

@ miopenLRNWithinChannel

Definition: miopen.h:476

miopenLRNCrossChannel

@ miopenLRNCrossChannel

Definition: miopen.h:477

MIOPEN_SOFTMAX_MODE_INSTANCE

@ MIOPEN_SOFTMAX_MODE_INSTANCE

Definition: miopen.h:549

MIOPEN_SOFTMAX_MODE_CHANNEL

@ MIOPEN_SOFTMAX_MODE_CHANNEL

Definition: miopen.h:550

MIOPEN_SOFTMAX_FAST

@ MIOPEN_SOFTMAX_FAST

Definition: miopen.h:538

MIOPEN_SOFTMAX_ACCURATE

@ MIOPEN_SOFTMAX_ACCURATE

Definition: miopen.h:539

MIOPEN_SOFTMAX_LOG

@ MIOPEN_SOFTMAX_LOG

Definition: miopen.h:540

miopenConvAlgoPerf_t

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

Definition: miopen.h:1280

miopenConvAlgoPerf_t::fwd_algo

miopenConvFwdAlgorithm_t fwd_algo

Definition: miopen.h:1283

miopenConvAlgoPerf_t::bwd_data_algo

miopenConvBwdDataAlgorithm_t bwd_data_algo

Definition: miopen.h:1287

miopenConvAlgoPerf_t::memory

size_t memory

Definition: miopen.h:1291

miopenConvAlgoPerf_t::bwd_weights_algo

miopenConvBwdWeightsAlgorithm_t bwd_weights_algo

Definition: miopen.h:1284

miopenConvAlgoPerf_t::time

float time

Definition: miopen.h:1290

miopenConvSolution_t

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

Definition: miopen.h:1304

miopenConvSolution_t::algorithm

miopenConvAlgorithm_t algorithm

Definition: miopen.h:1311

miopenConvSolution_t::solution_id

uint64_t solution_id

Definition: miopen.h:1310

miopenConvSolution_t::workspace_size

size_t workspace_size

Definition: miopen.h:1308

miopenConvSolution_t::time

float time

Definition: miopen.h:1305

miopenTensorArgument_t

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

Definition: miopen.h:6244

miopenTensorArgument_t::id

miopenTensorArgumentId_t id

Definition: miopen.h:6247

miopenTensorArgument_t::buffer

void * buffer

Definition: miopen.h:6257

miopenTensorArgument_t::descriptor

miopenTensorDescriptor_t * descriptor

Definition: miopen.h:6253