/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 

3117 MIOPEN_EXPORT miopenStatus_t miopenBatchNormalizationForwardInferenceInvVariance(

3118  miopenHandle_t handle,

3119  miopenBatchNormMode_t bn_mode,

3120  void* alpha,

3121  void* beta,

3122  const miopenTensorDescriptor_t xDesc,

3123  const void* x,

3124  const miopenTensorDescriptor_t yDesc,

3125  void* y,

3126  const miopenTensorDescriptor_t scaleDesc,

3127  const miopenTensorDescriptor_t biasDesc,

3128  const miopenTensorDescriptor_t estMeanDesc,

3129  const miopenTensorDescriptor_t estInvVarianceDesc,

3130  void* bnScale,

3131  void* bnBias,

3132  void* estimatedMean,

3133  void* estimatedInvVariance);

3134 

3165 MIOPEN_EXPORT miopenStatus_t miopenBatchNormForwardInferenceActivationInvVariance(

3166  miopenHandle_t handle,

3167  miopenBatchNormMode_t bn_mode,

3168  void* alpha,

3169  void* beta,

3170  const miopenTensorDescriptor_t xDesc,

3171  const void* x,

3172  const miopenTensorDescriptor_t yDesc,

3173  void* y,

3174  const miopenTensorDescriptor_t scaleDesc,

3175  const miopenTensorDescriptor_t biasDesc,

3176  const miopenTensorDescriptor_t estMeanDesc,

3177  const miopenTensorDescriptor_t estInvVarianceDesc,

3178  void* bnScale,

3179  void* bnBias,

3180  void* estimatedMean,

3181  void* estimatedInvVariance,

3182  const miopenActivationDescriptor_t activDesc);

3183 

3216 MIOPEN_EXPORT miopenStatus_t

3217 miopenBatchNormForwardInferenceActivation(miopenHandle_t handle,

3218  miopenBatchNormMode_t bn_mode,

3219  void* alpha,

3220  void* beta,

3221  const miopenTensorDescriptor_t xDesc,

3222  const void* x,

3223  const miopenTensorDescriptor_t yDesc,

3224  void* y,

3225  const miopenTensorDescriptor_t scaleDesc,

3226  const miopenTensorDescriptor_t biasDesc,

3227  const miopenTensorDescriptor_t estMeanDesc,

3228  const miopenTensorDescriptor_t estVarianceDesc,

3229  void* bnScale,

3230  void* bnBias,

3231  void* estimatedMean,

3232  void* estimatedVariance,

3233  double epsilon,

3234  const miopenActivationDescriptor_t activDesc);

3235 

3270 MIOPEN_EXPORT miopenStatus_t

3271 miopenBatchNormalizationBackward(miopenHandle_t handle,

3272  miopenBatchNormMode_t bn_mode,

3273  const void* alphaDataDiff,

3274  const void* betaDataDiff,

3275  const void* alphaParamDiff,

3276  const void* betaParamDiff,

3277  const miopenTensorDescriptor_t xDesc,

3278  const void* x,

3279  const miopenTensorDescriptor_t dyDesc,

3280  const void* dy,

3281  const miopenTensorDescriptor_t dxDesc,

3282  void* dx,

3283  const miopenTensorDescriptor_t bnScaleBiasDiffDesc,

3284  const void* bnScale,

3285  void* resultBnScaleDiff,

3286  void* resultBnBiasDiff,

3287  double epsilon,

3288  const void* savedMean,

3289  const void* savedInvVariance);

3290 

3329 MIOPEN_EXPORT miopenStatus_t

3330 miopenBatchNormalizationBackward_V2(miopenHandle_t handle,

3331  miopenBatchNormMode_t bn_mode,

3332  const void* alphaDataDiff,

3333  const void* betaDataDiff,

3334  const void* alphaParamDiff,

3335  const void* betaParamDiff,

3336  const miopenTensorDescriptor_t xDesc,

3337  const void* x,

3338  const miopenTensorDescriptor_t dyDesc,

3339  const void* dy,

3340  const miopenTensorDescriptor_t dxDesc,

3341  void* dx,

3342  const miopenTensorDescriptor_t scaleDesc,

3343  const miopenTensorDescriptor_t biasDesc,

3344  const miopenTensorDescriptor_t savedMeanDesc,

3345  const miopenTensorDescriptor_t savedVarDesc,

3346  const void* bnScale,

3347  void* resultBnScaleDiff,

3348  void* resultBnBiasDiff,

3349  double epsilon,

3350  const void* savedMean,

3351  const void* savedInvVariance);

3352 

3393 MIOPEN_EXPORT miopenStatus_t

3394 miopenBatchNormBackwardActivation(miopenHandle_t handle,

3395  miopenBatchNormMode_t bn_mode,

3396  const void* alphaDataDiff,

3397  const void* betaDataDiff,

3398  const void* alphaParamDiff,

3399  const void* betaParamDiff,

3400  const miopenTensorDescriptor_t xDesc,

3401  const void* x,

3402  const miopenTensorDescriptor_t dyDesc,

3403  const void* dy,

3404  const miopenTensorDescriptor_t dxDesc,

3405  void* dx,

3406  const miopenTensorDescriptor_t scaleDesc,

3407  const miopenTensorDescriptor_t biasDesc,

3408  const miopenTensorDescriptor_t savedMeanDesc,

3409  const miopenTensorDescriptor_t savedVarianceDesc,

3410  const void* bnScale,

3411  const void* bnBias,

3412  void* resultBnScaleDiff,

3413  void* resultBnBiasDiff,

3414  double epsilon,

3415  const void* savedMean,

3416  const void* savedInvVariance,

3417  const miopenActivationDescriptor_t activDesc);

3419 // CLOSEOUT BATCHNORM DOXYGEN GROUP

3420 

3421 // Activation APIs

3431 MIOPEN_EXPORT miopenStatus_t

3432 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);

3433 

3445 MIOPEN_EXPORT miopenStatus_t

3446 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3447  miopenActivationMode_t mode,

3448  double activAlpha,

3449  double activBeta,

3450  double activGamma);

3451 

3463 MIOPEN_EXPORT miopenStatus_t

3464 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,

3465  miopenActivationMode_t* mode,

3466  double* activAlpha,

3467  double* activBeta,

3468  double* activGamma);

3469 

3482 MIOPEN_EXPORT miopenStatus_t miopenActivationForward(miopenHandle_t handle,

3483  const miopenActivationDescriptor_t activDesc,

3484  const void* alpha,

3485  const miopenTensorDescriptor_t xDesc,

3486  const void* x,

3487  const void* beta,

3488  const miopenTensorDescriptor_t yDesc,

3489  void* y);

3490 

3507 MIOPEN_EXPORT miopenStatus_t miopenActivationBackward(miopenHandle_t handle,

3508  const miopenActivationDescriptor_t activDesc,

3509  const void* alpha,

3510  const miopenTensorDescriptor_t yDesc,

3511  const void* y,

3512  const miopenTensorDescriptor_t dyDesc,

3513  const void* dy,

3514  const miopenTensorDescriptor_t xDesc,

3515  const void* x,

3516  const void* beta,

3517  const miopenTensorDescriptor_t dxDesc,

3518  void* dx);

3519 

3525 MIOPEN_EXPORT miopenStatus_t

3526 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);

3527 

3529 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3530 

3531 #ifdef MIOPEN_BETA_API

3547 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,

3548  const miopenTensorDescriptor_t inputDesc,

3549  const void* input,

3550  const miopenTensorDescriptor_t outputDesc,

3551  void* output,

3552  const uint32_t dim);

3553 

3566 MIOPEN_EXPORT miopenStatus_t miopenGLUBackward(miopenHandle_t handle,

3567  const miopenTensorDescriptor_t inputDesc,

3568  const void* input,

3569  const miopenTensorDescriptor_t outputGradDesc,

3570  const void* outputGrad,

3571  const miopenTensorDescriptor_t inputGradDesc,

3572  void* inputGrad,

3573  const uint32_t dim);

3574 

3576 // CLOSEOUT ACTIVATION DOXYGEN GROUP

3577 #endif // MIOPEN_BETA_API

3578 

3579 // Softmax APIs

3597 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward(miopenHandle_t handle,

3598  const void* alpha,

3599  const miopenTensorDescriptor_t xDesc,

3600  const void* x,

3601  const void* beta,

3602  const miopenTensorDescriptor_t yDesc,

3603  void* y);

3604 

3620 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward(miopenHandle_t handle,

3621  const void* alpha,

3622  const miopenTensorDescriptor_t yDesc,

3623  const void* y,

3624  const miopenTensorDescriptor_t dyDesc,

3625  const void* dy,

3626  const void* beta,

3627  const miopenTensorDescriptor_t dxDesc,

3628  void* dx);

3629 

3643 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxForward_V2(miopenHandle_t handle,

3644  const void* alpha,

3645  const miopenTensorDescriptor_t xDesc,

3646  const void* x,

3647  const void* beta,

3648  const miopenTensorDescriptor_t yDesc,

3649  void* y,

3650  miopenSoftmaxAlgorithm_t algorithm,

3651  miopenSoftmaxMode_t mode);

3652 

3668 MIOPEN_EXPORT miopenStatus_t miopenSoftmaxBackward_V2(miopenHandle_t handle,

3669  const void* alpha,

3670  const miopenTensorDescriptor_t yDesc,

3671  const void* y,

3672  const miopenTensorDescriptor_t dyDesc,

3673  const void* dy,

3674  const void* beta,

3675  const miopenTensorDescriptor_t dxDesc,

3676  void* dx,

3677  miopenSoftmaxAlgorithm_t algorithm,

3678  miopenSoftmaxMode_t mode);

3679 

3681 // CLOSEOUT SOFTMAX DOXYGEN GROUP

3682 

3686 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);

3687 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);

3688 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);

3689 

3698 typedef enum

3699 {

3700  miopenVerticalFusion = 0,

3701  miopenHorizontalFusion = 1,

3702 } miopenFusionDirection_t;

3703 

3711 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,

3712  const miopenFusionDirection_t fuseDirection,

3713  const miopenTensorDescriptor_t inputDesc);

3714 

3720 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);

3721 

3728 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,

3729  miopenFusionPlanDescriptor_t fusePlanDesc);

3730 

3741 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,

3742  const int op_idx,

3743  miopenFusionOpDescriptor_t* op);

3744 

3752 MIOPEN_EXPORT miopenStatus_t

3753 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,

3754  miopenFusionPlanDescriptor_t fusePlanDesc,

3755  size_t* workSpaceSize,

3756  miopenConvFwdAlgorithm_t algo);

3757 

3775 MIOPEN_EXPORT miopenStatus_t

3776 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,

3777  const int requestAlgoCount,

3778  int* returnedAlgoCount,

3779  miopenConvFwdAlgorithm_t* returnedAlgos);

3780 

3790 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(

3791  miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);

3792 

3801 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3802  miopenFusionOpDescriptor_t* convOp,

3803  miopenConvolutionDescriptor_t convDesc,

3804  const miopenTensorDescriptor_t wDesc);

3805 

3806 //---

3807 

3808 // Activation forward create ops ---

3816 MIOPEN_EXPORT miopenStatus_t

3817 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3818  miopenFusionOpDescriptor_t* activFwdOp,

3819  miopenActivationMode_t mode);

3820 

3821 // Activation backward create ops ---

3829 MIOPEN_EXPORT miopenStatus_t

3830 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3831  miopenFusionOpDescriptor_t* activBwdOp,

3832  miopenActivationMode_t mode);

3833 

3834 // Bias create ops ---

3842 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3843  miopenFusionOpDescriptor_t* biasOp,

3844  const miopenTensorDescriptor_t bDesc);

3845 

3846 // Batch normalization create ops ---

3855 MIOPEN_EXPORT miopenStatus_t

3856 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,

3857  miopenFusionOpDescriptor_t* bnOp,

3858  const miopenBatchNormMode_t bn_mode,

3859  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);

3860 

3870 MIOPEN_EXPORT miopenStatus_t

3871 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,

3872  miopenFusionOpDescriptor_t* bnFwdOp,

3873  const miopenBatchNormMode_t bn_mode,

3874  bool runningMeanVariance);

3875 

3883 MIOPEN_EXPORT miopenStatus_t

3884 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,

3885  miopenFusionOpDescriptor_t* bnBwdOp,

3886  const miopenBatchNormMode_t bn_mode);

3887 

3888 //---

3894 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);

3895 

3901 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);

3902 

3903 // Convolution set arguments ---

3913 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,

3914  const miopenFusionOpDescriptor_t convOp,

3915  const void* alpha,

3916  const void* beta,

3917  const void* w);

3918 // Activation set arguments ---

3930 MIOPEN_EXPORT miopenStatus_t

3931 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,

3932  const miopenFusionOpDescriptor_t activFwdOp,

3933  const void* alpha,

3934  const void* beta,

3935  double activAlpha,

3936  double activBeta,

3937  double activGamma);

3938 

3952 MIOPEN_EXPORT miopenStatus_t

3953 miopenSetOpArgsActivBackward(miopenOperatorArgs_t args,

3954  const miopenFusionOpDescriptor_t activBwdOp,

3955  const void* alpha,

3956  const void* beta,

3957  const void* y,

3958  const void* reserved,

3959  double activAlpha,

3960  double activBeta,

3961  double activGamma);

3962 

3963 // Batch Normalization set arguments ---

3977 MIOPEN_EXPORT miopenStatus_t

3978 miopenSetOpArgsBatchNormInference(miopenOperatorArgs_t args,

3979  const miopenFusionOpDescriptor_t bnOp,

3980  const void* alpha,

3981  const void* beta,

3982  const void* bnScale,

3983  const void* bnBias,

3984  const void* estimatedMean,

3985  const void* estimatedVariance,

3986  double epsilon);

3987 

4004 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormForward(miopenOperatorArgs_t args,

4005  const miopenFusionOpDescriptor_t bnOp,

4006  const void* alpha,

4007  const void* beta,

4008  const void* bnScale,

4009  const void* bnBias,

4010  void* savedMean,

4011  void* savedInvVariance,

4012  void* runningMean,

4013  void* runningVariance,

4014  double expAvgFactor,

4015  double epsilon);

4016 

4032 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBatchNormBackward(miopenOperatorArgs_t args,

4033  const miopenFusionOpDescriptor_t bnOp,

4034  const void* alpha,

4035  const void* beta,

4036  const void* x,

4037  const void* bnScale,

4038  const void* bnBias,

4039  void* resultBnScaleDiff,

4040  void* resultBnBiasDiff,

4041  const void* savedMean,

4042  const void* savedInvVariance);

4043 

4044 // Bias forward set arguments ---

4054 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,

4055  const miopenFusionOpDescriptor_t biasOp,

4056  const void* alpha,

4057  const void* beta,

4058  const void* bias);

4059 

4074 MIOPEN_EXPORT miopenStatus_t

4075 miopenExecuteFusionPlan(const miopenHandle_t handle,

4076  const miopenFusionPlanDescriptor_t fusePlanDesc,

4077  const miopenTensorDescriptor_t inputDesc,

4078  const void* input,

4079  const miopenTensorDescriptor_t outputDesc,

4080  void* output,

4081  miopenOperatorArgs_t args);

4082 

4097 MIOPEN_EXPORT miopenStatus_t

4098 miopenExecuteFusionPlan_v2(const miopenHandle_t handle,

4099  const miopenFusionPlanDescriptor_t fusePlanDesc,

4100  const miopenTensorDescriptor_t inputDesc,

4101  const void* input,

4102  const miopenTensorDescriptor_t outputDesc,

4103  void* output,

4104  miopenOperatorArgs_t args,

4105  void* workspace,

4106  size_t workspaceSize);

4107 

4131 MIOPEN_EXPORT miopenStatus_t

4132 miopenConvolutionBiasActivationForward(miopenHandle_t handle,

4133  const void* alpha1,

4134  const miopenTensorDescriptor_t xDesc,

4135  const void* x,

4136  const miopenTensorDescriptor_t wDesc,

4137  const void* w,

4138  const miopenConvolutionDescriptor_t convDesc,

4139  miopenConvFwdAlgorithm_t algo,

4140  void* workspace,

4141  size_t workspaceSizeInBytes,

4142  const void* alpha2,

4143  const miopenTensorDescriptor_t zDesc,

4144  const void* z,

4145  const miopenTensorDescriptor_t biasDesc,

4146  const void* bias,

4147  const miopenActivationDescriptor_t activationDesc,

4148  const miopenTensorDescriptor_t yDesc,

4149  void* y);

4151 // CLOSEOUT FUSION DOXYGEN GROUP

4152 

4161 typedef enum

4162 {

4163  miopenRNNRELU = 0,

4164  miopenRNNTANH = 1,

4165  miopenLSTM = 2,

4166  miopenGRU = 3,

4167 } miopenRNNMode_t;

4168 

4172 typedef enum

4173 {

4174  miopenRNNlinear = 0,

4175  miopenRNNskip = 1,

4176 } miopenRNNInputMode_t;

4177 

4181 typedef enum

4182 {

4183  miopenRNNdefault = 0,

4185  miopenRNNfundamental = 1,

4187  miopenRNNroundedDynamic = 2,

4189 } miopenRNNAlgo_t;

4190 

4194 typedef enum

4195 {

4196  miopenRNNunidirection = 0,

4197  miopenRNNbidirection = 1,

4198 } miopenRNNDirectionMode_t;

4199 

4203 typedef enum

4204 {

4205  miopenRNNNoBias = 0,

4206  miopenRNNwithBias = 1,

4207 } miopenRNNBiasMode_t;

4208 

4212 typedef enum

4213 {

4214  miopenRNNAlgoGEMM = 0,

4215 } miopenRNNGEMMalgoMode_t;

4216 

4220 typedef enum

4221 {

4222  miopenRNNIONotPadded = 0,

4223  miopenRNNIOWithPadding = 1,

4224 } miopenRNNPaddingMode_t;

4225 

4229 typedef enum

4230 {

4231  miopenRNNTraining = 0,

4232  miopenRNNInference = 1,

4233 } miopenRNNFWDMode_t;

4234 

4238 typedef enum

4239 {

4240  miopenRNNDataUnknownLayout = 0,

4241  miopenRNNDataSeqMajorNotPadded = 1,

4242  miopenRNNDataSeqMajorPadded = 2,

4243  miopenRNNDataBatchMajorPadded = 3,

4244 } miopenRNNBaseLayout_t;

4245 

4252 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);

4253 

4266 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4267  miopenRNNMode_t* rnnMode,

4268  miopenRNNAlgo_t* algoMode,

4269  miopenRNNInputMode_t* inputMode,

4270  miopenRNNDirectionMode_t* dirMode,

4271  miopenRNNBiasMode_t* biasMode,

4272  int* hiddenSize,

4273  int* layer);

4274 

4291 MIOPEN_EXPORT miopenStatus_t miopenGetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4292  int* hiddenSize,

4293  int* layer,

4294  miopenDropoutDescriptor_t* dropoutDesc,

4295  miopenRNNInputMode_t* inputMode,

4296  miopenRNNDirectionMode_t* dirMode,

4297  miopenRNNMode_t* rnnMode,

4298  miopenRNNBiasMode_t* biasMode,

4299  miopenRNNAlgo_t* algoMode,

4300  miopenDataType_t* dataType);

4301 

4307 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);

4308 

4324 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor(miopenRNNDescriptor_t rnnDesc,

4325  const int hsize,

4326  const int nlayers,

4327  miopenRNNInputMode_t inMode,

4328  miopenRNNDirectionMode_t direction,

4329  miopenRNNMode_t rnnMode,

4330  miopenRNNBiasMode_t biasMode,

4331  miopenRNNAlgo_t algo,

4332  miopenDataType_t dataType);

4333 

4352 MIOPEN_EXPORT miopenStatus_t miopenSetRNNDescriptor_V2(miopenRNNDescriptor_t rnnDesc,

4353  const int hsize,

4354  const int nlayers,

4355  miopenDropoutDescriptor_t dropoutDesc,

4356  miopenRNNInputMode_t inMode,

4357  miopenRNNDirectionMode_t direction,

4358  miopenRNNMode_t rnnMode,

4359  miopenRNNBiasMode_t biasMode,

4360  miopenRNNAlgo_t algo,

4361  miopenDataType_t dataType);

4362 

4377 MIOPEN_EXPORT miopenStatus_t

4378 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4379  miopenDataType_t dataType,

4380  miopenRNNBaseLayout_t layout,

4381  int maxSequenceLen,

4382  int batchSize,

4383  int vectorSize,

4384  const int* sequenceLenArray,

4385  void* paddingMarker);

4386 

4405 MIOPEN_EXPORT miopenStatus_t

4406 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,

4407  miopenDataType_t* dataType,

4408  miopenRNNBaseLayout_t* layout,

4409  int* maxSequenceLen,

4410  int* batchSize,

4411  int* vectorSize,

4412  int sequenceLenArrayLimit,

4413  int* sequenceLenArray,

4414  void* paddingMarker);

4415 

4432 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,

4433  const miopenRNNDescriptor_t rnnDesc,

4434  const int sequenceLen,

4435  const miopenTensorDescriptor_t* xDesc,

4436  size_t* numBytes);

4437 

4454 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,

4455  miopenRNNDescriptor_t rnnDesc,

4456  const int sequenceLen,

4457  const miopenTensorDescriptor_t* xDesc,

4458  size_t* numBytes);

4459 

4476 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,

4477  miopenRNNDescriptor_t rnnDesc,

4478  miopenSeqTensorDescriptor_t xDesc,

4479  miopenRNNFWDMode_t fwdMode,

4480  size_t* workSpaceSize,

4481  size_t* reserveSpaceSize);

4482 

4495 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,

4496  miopenRNNDescriptor_t rnnDesc,

4497  miopenTensorDescriptor_t xDesc,

4498  size_t* numBytes,

4499  miopenDataType_t dtype);

4500 

4513 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,

4514  miopenRNNDescriptor_t rnnDesc,

4515  miopenTensorDescriptor_t xDesc,

4516  miopenTensorDescriptor_t wDesc,

4517  miopenDataType_t dtype);

4518 

4536 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,

4537  miopenRNNDescriptor_t rnnDesc,

4538  const int seqLen,

4539  miopenTensorDescriptor_t* xDesc,

4540  size_t* numBytes);

4541 

4554 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,

4555  miopenRNNDescriptor_t rnnDesc,

4556  const int seqLen,

4557  miopenTensorDescriptor_t* xDesc,

4558  size_t* numBytes);

4559 

4600 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,

4601  miopenRNNDescriptor_t rnnDesc,

4602  const int layer,

4603  miopenTensorDescriptor_t xDesc,

4604  const int paramID,

4605  size_t* numBytes);

4606 

4644 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,

4645  miopenRNNDescriptor_t rnnDesc,

4646  const int layer,

4647  const int biasID,

4648  size_t* numBytes);

4649 

4708 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParam(miopenHandle_t handle,

4709  miopenRNNDescriptor_t rnnDesc,

4710  const int layer,

4711  miopenTensorDescriptor_t xDesc,

4712  miopenTensorDescriptor_t wDesc,

4713  const void* w,

4714  const int paramID,

4715  miopenTensorDescriptor_t paramDesc,

4716  void* layerParam);

4717 

4775 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBias(miopenHandle_t handle,

4776  miopenRNNDescriptor_t rnnDesc,

4777  const int layer,

4778  miopenTensorDescriptor_t xDesc,

4779  miopenTensorDescriptor_t wDesc,

4780  const void* w,

4781  const int biasID,

4782  miopenTensorDescriptor_t biasDesc,

4783  void* layerBias);

4784 

4839 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,

4840  const int layer,

4841  miopenTensorDescriptor_t xDesc,

4842  const int paramID,

4843  miopenTensorDescriptor_t paramDesc,

4844  size_t* layerParamOffset);

4845 

4896 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,

4897  const int layer,

4898  miopenTensorDescriptor_t xDesc,

4899  const int biasID,

4900  miopenTensorDescriptor_t biasDesc,

4901  size_t* layerBiasOffset);

4902 

4955 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerParam(miopenHandle_t handle,

4956  miopenRNNDescriptor_t rnnDesc,

4957  const int layer,

4958  miopenTensorDescriptor_t xDesc,

4959  miopenTensorDescriptor_t wDesc,

4960  void* w,

4961  const int paramID,

4962  miopenTensorDescriptor_t paramDesc,

4963  const void* layerParam);

4964 

5015 MIOPEN_EXPORT miopenStatus_t miopenSetRNNLayerBias(miopenHandle_t handle,

5016  miopenRNNDescriptor_t rnnDesc,

5017  const int layer,

5018  miopenTensorDescriptor_t xDesc,

5019  miopenTensorDescriptor_t wDesc,

5020  void* w,

5021  const int biasID,

5022  miopenTensorDescriptor_t biasDesc,

5023  const void* layerBias);

5024 

5036 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5037  miopenRNNPaddingMode_t paddingMode);

5038 

5046 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,

5047  miopenRNNPaddingMode_t* paddingMode);

5048 

5099 MIOPEN_EXPORT miopenStatus_t miopenRNNForward(miopenHandle_t handle,

5100  const miopenRNNDescriptor_t rnnDesc,

5101  miopenRNNFWDMode_t fwdMode,

5102  const miopenSeqTensorDescriptor_t xDesc,

5103  const void* x,

5104  const miopenTensorDescriptor_t hDesc,

5105  const void* hx,

5106  void* hy,

5107  const miopenTensorDescriptor_t cDesc,

5108  const void* cx,

5109  void* cy,

5110  const miopenSeqTensorDescriptor_t yDesc,

5111  void* y,

5112  const void* w,

5113  size_t weightSpaceSize,

5114  void* workSpace,

5115  size_t workSpaceNumBytes,

5116  void* reserveSpace,

5117  size_t reserveSpaceNumBytes);

5118 

5168 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardSeqData(miopenHandle_t handle,

5169  const miopenRNNDescriptor_t rnnDesc,

5170  const miopenSeqTensorDescriptor_t yDesc,

5171  const void* y,

5172  const void* dy,

5173  const miopenTensorDescriptor_t hDesc,

5174  const void* hx,

5175  const void* dhy,

5176  void* dhx,

5177  const miopenTensorDescriptor_t cDesc,

5178  const void* cx,

5179  const void* dcy,

5180  void* dcx,

5181  const miopenSeqTensorDescriptor_t xDesc,

5182  void* dx,

5183  const void* w,

5184  size_t weightSpaceSize,

5185  void* workSpace,

5186  size_t workSpaceNumBytes,

5187  void* reserveSpace,

5188  size_t reserveSpaceNumBytes);

5189 

5223 MIOPEN_EXPORT miopenStatus_t

5224 miopenRNNBackwardWeightsSeqTensor(miopenHandle_t handle,

5225  const miopenRNNDescriptor_t rnnDesc,

5226  const miopenSeqTensorDescriptor_t xDesc,

5227  const void* x,

5228  const miopenTensorDescriptor_t hDesc,

5229  const void* hx,

5230  const miopenSeqTensorDescriptor_t yDesc,

5231  const void* y,

5232  void* dw,

5233  size_t weightSpaceSize,

5234  void* workSpace,

5235  size_t workSpaceNumBytes,

5236  const void* reserveSpace,

5237  size_t reserveSpaceNumBytes);

5238 

5296 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardTraining(miopenHandle_t handle,

5297  const miopenRNNDescriptor_t rnnDesc,

5298  const int sequenceLen,

5299  const miopenTensorDescriptor_t* xDesc,

5300  const void* x,

5301  const miopenTensorDescriptor_t hxDesc,

5302  const void* hx,

5303  const miopenTensorDescriptor_t cxDesc,

5304  const void* cx,

5305  const miopenTensorDescriptor_t wDesc,

5306  const void* w,

5307  const miopenTensorDescriptor_t* yDesc,

5308  void* y,

5309  const miopenTensorDescriptor_t hyDesc,

5310  void* hy,

5311  const miopenTensorDescriptor_t cyDesc,

5312  void* cy,

5313  void* workSpace,

5314  size_t workSpaceNumBytes,

5315  void* reserveSpace,

5316  size_t reserveSpaceNumBytes);

5317 

5390 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardData(miopenHandle_t handle,

5391  const miopenRNNDescriptor_t rnnDesc,

5392  const int sequenceLen,

5393  const miopenTensorDescriptor_t* yDesc,

5394  const void* y,

5395  const miopenTensorDescriptor_t* dyDesc,

5396  const void* dy,

5397  const miopenTensorDescriptor_t dhyDesc,

5398  const void* dhy,

5399  const miopenTensorDescriptor_t dcyDesc,

5400  const void* dcy,

5401  const miopenTensorDescriptor_t wDesc,

5402  const void* w,

5403  const miopenTensorDescriptor_t hxDesc,

5404  const void* hx,

5405  const miopenTensorDescriptor_t cxDesc,

5406  const void* cx,

5407  const miopenTensorDescriptor_t* dxDesc,

5408  void* dx,

5409  const miopenTensorDescriptor_t dhxDesc,

5410  void* dhx,

5411  const miopenTensorDescriptor_t dcxDesc,

5412  void* dcx,

5413  void* workSpace,

5414  size_t workSpaceNumBytes,

5415  void* reserveSpace,

5416  size_t reserveSpaceNumBytes);

5417 

5454 MIOPEN_EXPORT miopenStatus_t miopenRNNBackwardWeights(miopenHandle_t handle,

5455  const miopenRNNDescriptor_t rnnDesc,

5456  const int sequenceLen,

5457  const miopenTensorDescriptor_t* xDesc,

5458  const void* x,

5459  const miopenTensorDescriptor_t hxDesc,

5460  const void* hx,

5461  const miopenTensorDescriptor_t* yDesc,

5462  const void* y,

5463  const miopenTensorDescriptor_t dwDesc,

5464  void* dw,

5465  void* workSpace,

5466  size_t workSpaceNumBytes,

5467  const void* reserveSpace,

5468  size_t reserveSpaceNumBytes);

5469 

5525 MIOPEN_EXPORT miopenStatus_t miopenRNNForwardInference(miopenHandle_t handle,

5526  miopenRNNDescriptor_t rnnDesc,

5527  const int sequenceLen,

5528  const miopenTensorDescriptor_t* xDesc,

5529  const void* x,

5530  const miopenTensorDescriptor_t hxDesc,

5531  const void* hx,

5532  const miopenTensorDescriptor_t cxDesc,

5533  const void* cx,

5534  const miopenTensorDescriptor_t wDesc,

5535  const void* w,

5536  const miopenTensorDescriptor_t* yDesc,

5537  void* y,

5538  const miopenTensorDescriptor_t hyDesc,

5539  void* hy,

5540  const miopenTensorDescriptor_t cyDesc,

5541  void* cy,

5542  void* workSpace,

5543  size_t workSpaceNumBytes);

5544 

5546 // CLOSEOUT RNN DOXYGEN GROUP

5547 

5556 typedef enum

5557 {

5558  MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0,

5559 } miopenCTCLossAlgo_t;

5560 

5567 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);

5568 

5578 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5579  miopenDataType_t* dataType,

5580  int* blank_label_id,

5581  bool* apply_softmax_layer);

5582 

5588 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);

5589 

5599 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,

5600  miopenDataType_t dataType,

5601  const int blank_label_id,

5602  bool apply_softmax_layer);

5603 

5620 MIOPEN_EXPORT miopenStatus_t

5621 miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,

5622  const miopenTensorDescriptor_t probsDesc,

5623  const miopenTensorDescriptor_t gradientsDesc,

5624  const int* labels,

5625  const int* labelLengths,

5626  const int* inputLengths,

5627  miopenCTCLossAlgo_t algo,

5628  const miopenCTCLossDescriptor_t ctcLossDesc,

5629  size_t* workSpaceSize);

5630 

5650 MIOPEN_EXPORT miopenStatus_t miopenCTCLoss(miopenHandle_t handle,

5651  const miopenTensorDescriptor_t probsDesc,

5652  const void* probs,

5653  const int* labels,

5654  const int* labelLengths,

5655  const int* inputLengths,

5656  void* losses,

5657  const miopenTensorDescriptor_t gradientsDesc,

5658  void* gradients,

5659  miopenCTCLossAlgo_t algo,

5660  const miopenCTCLossDescriptor_t ctcLossDesc,

5661  void* workSpace,

5662  size_t workSpaceSize);

5663 

5665 // CLOSEOUT LossFunction DOXYGEN GROUP

5666 

5667 // Dropout APIs

5676 typedef enum

5677 {

5678  MIOPEN_RNG_PSEUDO_XORWOW = 0,

5679 } miopenRNGType_t;

5680 

5686 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);

5687 

5693 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);

5694 

5703 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,

5704  size_t* reserveSpaceSizeInBytes);

5705 

5714 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,

5715  size_t* stateSizeInBytes);

5716 

5733 MIOPEN_EXPORT miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5734  miopenHandle_t handle,

5735  float* dropout,

5736  void** states,

5737  unsigned long long* seed,

5738  bool* use_mask,

5739  bool* state_evo,

5740  miopenRNGType_t* rng_mode);

5741 

5764 MIOPEN_EXPORT miopenStatus_t miopenRestoreDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5765  miopenHandle_t handle,

5766  float dropout,

5767  void* states,

5768  size_t stateSizeInBytes,

5769  unsigned long long seed,

5770  bool use_mask,

5771  bool state_evo,

5772  miopenRNGType_t rng_mode);

5773 

5793 MIOPEN_EXPORT miopenStatus_t miopenSetDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc,

5794  miopenHandle_t handle,

5795  float dropout,

5796  void* states,

5797  size_t stateSizeInBytes,

5798  unsigned long long seed,

5799  bool use_mask,

5800  bool state_evo,

5801  miopenRNGType_t rng_mode);

5802 

5820 MIOPEN_EXPORT miopenStatus_t miopenDropoutForward(miopenHandle_t handle,

5821  const miopenDropoutDescriptor_t dropoutDesc,

5822  const miopenTensorDescriptor_t noise_shape,

5823  const miopenTensorDescriptor_t xDesc,

5824  const void* x,

5825  const miopenTensorDescriptor_t yDesc,

5826  void* y,

5827  void* reserveSpace,

5828  size_t reserveSpaceSizeInBytes);

5829 

5847 MIOPEN_EXPORT miopenStatus_t miopenDropoutBackward(miopenHandle_t handle,

5848  const miopenDropoutDescriptor_t dropoutDesc,

5849  const miopenTensorDescriptor_t noise_shape,

5850  const miopenTensorDescriptor_t dyDesc,

5851  const void* dy,

5852  const miopenTensorDescriptor_t dxDesc,

5853  void* dx,

5854  void* reserveSpace,

5855  size_t reserveSpaceSizeInBytes);

5856 

5858 // CLOSEOUT DROPOUT DOXYGEN GROUP

5859 

5860 // TensorReduce APIs

5871 MIOPEN_EXPORT miopenStatus_t

5872 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);

5873 

5879 MIOPEN_EXPORT miopenStatus_t

5880 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);

5881 

5894 MIOPEN_EXPORT miopenStatus_t

5895 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,

5896  miopenReduceTensorOp_t reduceTensorOp,

5897  miopenDataType_t reduceTensorCompType,

5898  miopenNanPropagation_t reduceTensorNanOpt,

5899  miopenReduceTensorIndices_t reduceTensorIndices,

5900  miopenIndicesType_t reduceTensorIndicesType);

5901 

5917 MIOPEN_EXPORT miopenStatus_t

5918 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,

5919  miopenReduceTensorOp_t* reduceTensorOp,

5920  miopenDataType_t* reduceTensorCompType,

5921  miopenNanPropagation_t* reduceTensorNanOpt,

5922  miopenReduceTensorIndices_t* reduceTensorIndices,

5923  miopenIndicesType_t* reduceTensorIndicesType);

5924 

5934 MIOPEN_EXPORT miopenStatus_t

5935 miopenGetReductionIndicesSize(miopenHandle_t handle,

5936  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5937  const miopenTensorDescriptor_t aDesc,

5938  const miopenTensorDescriptor_t cDesc,

5939  size_t* sizeInBytes);

5940 

5950 MIOPEN_EXPORT miopenStatus_t

5951 miopenGetReductionWorkspaceSize(miopenHandle_t handle,

5952  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5953  const miopenTensorDescriptor_t aDesc,

5954  const miopenTensorDescriptor_t cDesc,

5955  size_t* sizeInBytes);

5956 

5980 MIOPEN_EXPORT miopenStatus_t

5981 miopenReduceTensor(miopenHandle_t handle,

5982  const miopenReduceTensorDescriptor_t reduceTensorDesc,

5983  void* indices,

5984  size_t indicesSizeInBytes,

5985  void* workspace,

5986  size_t workspaceSizeInBytes,

5987  const void* alpha,

5988  const miopenTensorDescriptor_t aDesc,

5989  const void* A,

5990  const void* beta,

5991  const miopenTensorDescriptor_t cDesc,

5992  void* C);

5993 

5995 // CLOSEOUT TensorReduce DOXYGEN GROUP

5996 

5997 // Find 2.0 API

6008 MIOPEN_DECLARE_OBJECT(miopenProblem);

6009 

6013 typedef enum

6014 {

6015  miopenProblemDirectionForward = 0,

6016  miopenProblemDirectionBackward = 1,

6017  miopenProblemDirectionBackwardWeights = 2,

6018 #ifdef MIOPEN_BETA_API

6019  miopenProblemDirectionInference = 4,

6020 #endif

6021 } miopenProblemDirection_t;

6022 

6026 typedef enum

6027 {

6028  miopenTensorArgumentIdInvalid = 0,

6029  miopenTensorConvolutionX = 1,

6030  miopenTensorConvolutionW = 2,

6031  miopenTensorConvolutionY = 3,

6032 

6033  miopenTensorMhaK = 4,

6034  miopenTensorMhaQ = 5,

6035  miopenTensorMhaV = 6,

6036  miopenTensorMhaDescaleK = 7,

6037  miopenTensorMhaDescaleQ = 8,

6038  miopenTensorMhaDescaleV = 9,

6039  miopenTensorMhaDescaleS = 10,

6040  miopenTensorMhaScaleS = 11,

6041  miopenTensorMhaScaleO = 12,

6042  miopenTensorMhaDropoutProbability = 13,

6043  miopenTensorMhaDropoutSeed = 14,

6044  miopenTensorMhaDropoutOffset = 15,

6045  miopenTensorMhaO = 16,

6046  miopenTensorMhaAmaxO = 17,

6047  miopenTensorMhaAmaxS = 18,

6048  miopenTensorMhaM = 19,

6049  miopenTensorMhaZInv = 20,

6050  miopenTensorMhaDO = 21,

6051  miopenTensorMhaDescaleO = 22,

6052  miopenTensorMhaDescaleDO = 23,

6053  miopenTensorMhaDescaleDS = 24,

6054  miopenTensorMhaScaleDS = 25,

6055  miopenTensorMhaScaleDQ = 26,

6056  miopenTensorMhaScaleDK = 27,

6057  miopenTensorMhaScaleDV = 28,

6058  miopenTensorMhaDQ = 29,

6059  miopenTensorMhaDK = 30,

6060  miopenTensorMhaDV = 31,

6061  miopenTensorMhaAmaxDQ = 32,

6062  miopenTensorMhaAmaxDK = 33,

6063  miopenTensorMhaAmaxDV = 34,

6064  miopenTensorMhaAmaxDS = 35,

6065  miopenTensorMhaBias = 36,

6066 

6067 #ifdef MIOPEN_BETA_API

6068  miopenTensorActivationX = 37,

6069  miopenTensorActivationY = 38,

6070  miopenTensorActivationDX = 39,

6071  miopenTensorActivationDY = 40,

6072  miopenTensorBiasX = 41,

6073  miopenTensorBiasY = 42,

6074  miopenTensorBias = 43,

6075  miopenTensorSoftmaxX = 44,

6076  miopenTensorSoftmaxY = 45,

6077  miopenTensorSoftmaxDX = 46,

6078  miopenTensorSoftmaxDY = 47,

6079  miopenTensorBatchnormX = 48,

6080  miopenTensorBatchnormY = 49,

6081  miopenTensorBatchnormRunningMean = 50,

6082  miopenTensorBatchnormRunningVariance = 51,

6083  miopenTensorBatchnormSavedMean = 52,

6084  miopenTensorBatchnormSavedVariance = 53,

6085  miopenTensorBatchnormScale = 54,

6086  miopenTensorBatchnormScaleDiff = 55,

6087  miopenTensorBatchnormEstimatedMean = 56,

6088  miopenTensorBatchnormEstimatedVariance = 57,

6089  miopenTensorBatchnormBias = 58,

6090  miopenTensorBatchnormBiasDiff = 59,

6091  miopenTensorBatchnormDX = 60,

6092  miopenTensorBatchnormDY = 61,

6093 #endif

6094 

6095  miopenTensorArgumentIsScalar = 1U << 31,

6096 

6097  miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,

6098 #ifdef MIOPEN_BETA_API

6099  miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,

6100  miopenScalarBatchnormEpsilon = miopenTensorArgumentIsScalar | 3,

6101 #endif

6102 } miopenTensorArgumentId_t;

6103 

6107 typedef enum

6108 {

6109  miopenFindResultsOrderByTime = 0,

6110  miopenFindResultsOrderByWorkspaceSize = 1,

6111 } miopenFindResultsOrder_t;

6112 

6120 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,

6121  miopenConvolutionDescriptor_t operatorDesc,

6122  miopenProblemDirection_t direction);

6123 

6135 typedef enum

6136 {

6137  miopenMhaMaskNone = 0,

6138  miopenMhaMaskCausal = 1,

6139 } miopenMhaMask_t;

6140 

6141 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,

6142  miopenMhaDescriptor_t operatorDesc,

6143  miopenProblemDirection_t direction);

6144 

6151 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);

6152 

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

6163 

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

6174 

6181 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);

6182 

6194 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,

6195  float alpha,

6196  float beta,

6197  miopenSoftmaxAlgorithm_t algorithm,

6198  miopenSoftmaxMode_t mode);

6199 

6211 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,

6212  float* alpha,

6213  float* beta,

6214  miopenSoftmaxAlgorithm_t* algorithm,

6215  miopenSoftmaxMode_t* mode);

6216 

6222 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);

6223 

6231 MIOPEN_EXPORT miopenStatus_t

6232 miopenSetProblemTensorDescriptor(miopenProblem_t problem,

6233  miopenTensorArgumentId_t id,

6234  const miopenTensorDescriptor_t descriptor);

6235 

6238 MIOPEN_DECLARE_OBJECT(miopenFindOptions);

6239 

6245 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);

6246 

6252 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);

6253 

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

6261 

6268 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,

6269  miopenFindResultsOrder_t value);

6270 

6278 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,

6279  size_t value);

6280 

6288 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,

6289  void* buffer,

6290  size_t size);

6291 

6300 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,

6301  miopenTensorArgumentId_t id,

6302  void* buffer);

6303 

6311 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,

6312  unsigned attach);

6313 

6316 MIOPEN_DECLARE_OBJECT(miopenSolution);

6317 

6329 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,

6330  miopenProblem_t problem,

6331  miopenFindOptions_t options,

6332  miopenSolution_t* solutions,

6333  size_t* numSolutions,

6334  size_t maxSolutions);

6335 

6338 struct miopenTensorArgument_t

6339 {

6340  /* @brief Identifier of the tensor argument.

6341  */

6342  miopenTensorArgumentId_t id;

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

6344  *

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

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

6347  */

6348  miopenTensorDescriptor_t* descriptor;

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

6350  * the value is scalar.

6351  */

6352  void* buffer;

6353 };

6354 

6366 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,

6367  miopenSolution_t solution,

6368  size_t nInputs,

6369  const miopenTensorArgument_t* tensors,

6370  void* workspace,

6371  size_t workspaceSize);

6372 

6378 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);

6379 

6387 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,

6388  const char* data,

6389  size_t size);

6390 

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

6398 

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

6406 

6413 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,

6414  size_t* workspaceSize);

6415 

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

6423 

6430 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,

6431  uint64_t* solverId);

6432 

6439 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,

6440  miopenConvAlgorithm_t* result);

6441 

6442 #ifdef MIOPEN_BETA_API

6443 

6452 MIOPEN_EXPORT miopenStatus_t

6453 miopenCreateActivationProblem(miopenProblem_t* problem,

6454  miopenActivationDescriptor_t operatorDesc,

6455  miopenProblemDirection_t direction);

6456 

6465 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,

6466  miopenBatchNormMode_t mode,

6467  bool runningMeanVariance,

6468  miopenProblemDirection_t direction);

6469 

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

6490 

6498 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,

6499  miopenProblemDirection_t direction);

6500 

6509 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,

6510  miopenSoftmaxDescriptor_t operatorDesc,

6511  miopenProblemDirection_t direction);

6512 

6513 #endif

6514 

6516 // CLOSEOUT find2 DOXYGEN GROUP

6517 

6518 #ifdef MIOPEN_BETA_API

6519 

6524 typedef enum

6525 {

6526  MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0,

6527  MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =

6528  1,

6529 } miopenReduceCalculationNanPropagation_t;

6530 

6531 // ReduceCalculation APIs

6540 typedef enum

6541 {

6542  MIOPEN_REDUCE_CALCULATION_PROD =

6543  1,

6544  MIOPEN_REDUCE_CALCULATION_SUM =

6545  2,

6546 } miopenReduceCalculationOp_t;

6547 

6557 MIOPEN_EXPORT miopenStatus_t

6558 miopenGetReduceCalculationWorkspaceSize(miopenHandle_t handle,

6559  const miopenTensorDescriptor_t xDesc,

6560  const int32_t dim,

6561  const miopenReduceCalculationOp_t reduceCalculationOp,

6562  const miopenTensorDescriptor_t reduceDesc,

6563  size_t* sizeInBytes);

6564 

6578 MIOPEN_EXPORT miopenStatus_t

6579 miopenReduceCalculationForward(miopenHandle_t handle,

6580  miopenReduceCalculationNanPropagation_t nanPropagation,

6581  void* workspace,

6582  size_t workspaceSizeInBytes,

6583  const miopenTensorDescriptor_t xDesc,

6584  const void* x,

6585  const int32_t dim,

6586  const miopenReduceCalculationOp_t reduceCalculationOp,

6587  const miopenTensorDescriptor_t reduceDesc,

6588  void* y);

6589 

6591 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP

6592 #endif // MIOPEN_BETA_API

6593 

6594 #ifdef MIOPEN_BETA_API

6595 

6600 typedef enum

6601 {

6602  MIOPEN_REDUCE_EXTREME_ARGMIN =

6603  1,

6604  MIOPEN_REDUCE_EXTREME_ARGMAX =

6605  2,

6606  MIOPEN_REDUCE_EXTREME_MIN =

6607  3,

6608  MIOPEN_REDUCE_EXTREME_MAX =

6609  4,

6610 } miopenReduceExtremeOp_t;

6611 

6612 // ReduceExtreme APIs

6632 MIOPEN_EXPORT miopenStatus_t

6633 miopenReduceExtremeForward(miopenHandle_t handle,

6634  const miopenTensorDescriptor_t xDesc,

6635  const void* x,

6636  const int32_t dim,

6637  const miopenReduceExtremeOp_t reduceExtremeOp,

6638  const miopenTensorDescriptor_t yDesc,

6639  void* y,

6640  const miopenTensorDescriptor_t indiceDesc,

6641  void* indice);

6642 

6644 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP

6645 #endif // MIOPEN_BETA_API

6646 

6647 #ifdef MIOPEN_BETA_API

6648 // GroupNorm APIs

6673 MIOPEN_EXPORT miopenStatus_t miopenGroupNormForward(miopenHandle_t handle,

6674  miopenNormMode_t mode,

6675  const miopenTensorDescriptor_t xDesc,

6676  const void* x,

6677  const miopenTensorDescriptor_t weightDesc,

6678  const void* weight,

6679  const miopenTensorDescriptor_t biasDesc,

6680  const void* bias,

6681  const uint64_t num_groups,

6682  const float epsilon,

6683  const miopenTensorDescriptor_t yDesc,

6684  void* y,

6685  const miopenTensorDescriptor_t meanDesc,

6686  void* mean,

6687  const miopenTensorDescriptor_t rstdDesc,

6688  void* rstd);

6689 

6691 // CLOSEOUT groupnorm DOXYGEN GROUP

6692 #endif // MIOPEN_BETA_API

6693 

6694 #ifdef MIOPEN_BETA_API

6695 // LayerNorm APIs

6722 MIOPEN_EXPORT miopenStatus_t miopenAddLayerNormForward(miopenHandle_t handle,

6723  miopenNormMode_t mode,

6724  const miopenTensorDescriptor_t xDesc,

6725  const void* x,

6726  const miopenTensorDescriptor_t x2Desc,

6727  const void* x2,

6728  const miopenTensorDescriptor_t weightDesc,

6729  const void* weight,

6730  const miopenTensorDescriptor_t biasDesc,

6731  const void* bias,

6732  const float epsilon,

6733  const int32_t normalized_dim,

6734  const miopenTensorDescriptor_t yDesc,

6735  void* y,

6736  const miopenTensorDescriptor_t meanDesc,

6737  void* mean,

6738  const miopenTensorDescriptor_t rstdDesc,

6739  void* rstd);

6740 

6742 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6743 #endif // MIOPEN_BETA_API

6744 

6745 #ifdef MIOPEN_BETA_API

6746 // LayerNorm APIs

6766 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormForward(miopenHandle_t handle,

6767  miopenNormMode_t mode,

6768  const miopenTensorDescriptor_t xDesc,

6769  const void* x,

6770  const miopenTensorDescriptor_t weightDesc,

6771  const void* weight,

6772  const float epsilon,

6773  const miopenTensorDescriptor_t yDesc,

6774  void* y,

6775  const miopenTensorDescriptor_t rstdDesc,

6776  void* rstd);

6777 

6792 MIOPEN_EXPORT miopenStatus_t

6793 miopenGetT5LayerNormBackwardWorkspaceSize(miopenHandle_t handle,

6794  miopenNormMode_t mode,

6795  const miopenTensorDescriptor_t dyDesc,

6796  const miopenTensorDescriptor_t xDesc,

6797  const miopenTensorDescriptor_t weightDesc,

6798  const miopenTensorDescriptor_t rstdDesc,

6799  const miopenTensorDescriptor_t dxDesc,

6800  const miopenTensorDescriptor_t dwDesc,

6801  size_t* sizeInBytes);

6802 

6823 MIOPEN_EXPORT miopenStatus_t miopenT5LayerNormBackward(miopenHandle_t handle,

6824  miopenNormMode_t mode,

6825  void* workspace,

6826  size_t workspaceSizeInBytes,

6827  const miopenTensorDescriptor_t dyDesc,

6828  const void* dy,

6829  const miopenTensorDescriptor_t xDesc,

6830  const void* x,

6831  const miopenTensorDescriptor_t weightDesc,

6832  const void* weight,

6833  const miopenTensorDescriptor_t rstdDesc,

6834  const void* rstd,

6835  const miopenTensorDescriptor_t dxDesc,

6836  void* dx,

6837  const miopenTensorDescriptor_t dwDesc,

6838  void* dw);

6840 // CLOSEOUT LAYERNORM DOXYGEN GROUP

6841 #endif // MIOPEN_BETA_API

6842 

6843 #ifdef MIOPEN_BETA_API

6844 // Graph API

6856 typedef enum

6857 {

6858  MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,

6859  MIOPEN_BACKEND_ENGINE_DESCRIPTOR,

6860  MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,

6861  MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,

6862  MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,

6863  MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,

6864  MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,

6865  MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,

6866  MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,

6867  MIOPEN_BACKEND_MATMUL_DESCRIPTOR,

6868  MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,

6869  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,

6870  MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,

6871  MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,

6872  MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,

6873  MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,

6874  MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,

6875  MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,

6876  MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,

6877  MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,

6878  MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,

6879  MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,

6880  MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,

6881  MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,

6882  MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,

6883  MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,

6884  MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,

6885  MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,

6886  MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,

6887  MIOPEN_BACKEND_RNG_DESCRIPTOR,

6888  MIOPEN_BACKEND_TENSOR_DESCRIPTOR,

6889  MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,

6890 } miopenBackendDescriptorType_t;

6891 

6899 typedef enum

6900 {

6901  MIOPEN_ATTR_POINTWISE_MODE = 0,

6902  MIOPEN_ATTR_POINTWISE_MATH_PREC = 1,

6903  MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION = 2,

6904  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP = 3,

6905  MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP = 4,

6906  MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,

6907  MIOPEN_ATTR_POINTWISE_ELU_ALPHA = 6,

6908  MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA = 7,

6909  MIOPEN_ATTR_POINTWISE_SWISH_BETA = 8,

6910  MIOPEN_ATTR_POINTWISE_AXIS = 9,

6911 

6912  MIOPEN_ATTR_CONVOLUTION_COMP_TYPE = 100,

6913  MIOPEN_ATTR_CONVOLUTION_CONV_MODE = 101,

6914  MIOPEN_ATTR_CONVOLUTION_DILATIONS = 102,

6915  MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,

6916  MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS = 104,

6917  MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS = 105,

6918  MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS = 106,

6919 

6920  MIOPEN_ATTR_ENGINEHEUR_MODE = 200,

6921  MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,

6922  MIOPEN_ATTR_ENGINEHEUR_RESULTS = 202,

6923  MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,

6924 

6925  MIOPEN_ATTR_ENGINECFG_ENGINE = 300,

6926  MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,

6927  MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES = 302,

6928 

6929  MIOPEN_ATTR_EXECUTION_PLAN_HANDLE = 400,

6930  MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG = 401,

6931  MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE = 402,

6932  MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,

6933  MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,

6934  MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION = 405,

6935 

6936  MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID = 500,

6937  MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE = 501,

6938  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS = 502,

6939  MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,

6940 

6941  MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE = 600,

6942  MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,

6943 

6944  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA = 700,

6945  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA = 701,

6946  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC = 702,

6947  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W = 703,

6948  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X = 704,

6949  MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y = 705,

6950  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA = 706,

6951  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA = 707,

6952  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC = 708,

6953  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W = 709,

6954  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX = 710,

6955  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY = 711,

6956  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA = 712,

6957  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA = 713,

6958  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,

6959  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW = 715,

6960  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X = 716,

6961  MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY = 717,

6962  MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR = 750,

6963  MIOPEN_ATTR_OPERATION_POINTWISE_XDESC = 751,

6964  MIOPEN_ATTR_OPERATION_POINTWISE_BDESC = 752,

6965  MIOPEN_ATTR_OPERATION_POINTWISE_YDESC = 753,

6966  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1 = 754,

6967  MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2 = 755,

6968  MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC = 756,

6969  MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC = 757,

6970  MIOPEN_ATTR_OPERATION_POINTWISE_TDESC = 758,

6971 

6972  MIOPEN_ATTR_OPERATION_GENSTATS_MODE = 770,

6973  MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,

6974  MIOPEN_ATTR_OPERATION_GENSTATS_XDESC = 772,

6975  MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC = 773,

6976  MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,

6977 

6978  MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE = 780,

6979  MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC = 781,

6980  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC = 782,

6981  MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC = 783,

6982  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC = 784,

6983  MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC = 785,

6984  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC = 786,

6985  MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC = 787,

6986  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,

6987  MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC = 789,

6988  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC = 790,

6989  MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC = 791,

6990  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC = 792,

6991  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC = 793,

6992  MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC = 794,

6993  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC = 795,

6994  MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC = 796,

6995 

6996  MIOPEN_ATTR_OPERATIONGRAPH_HANDLE = 800,

6997  MIOPEN_ATTR_OPERATIONGRAPH_OPS = 801,

6998  MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,

6999 

7000  MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT = 900,

7001  MIOPEN_ATTR_TENSOR_DATA_TYPE = 901,

7002  MIOPEN_ATTR_TENSOR_DIMENSIONS = 902,

7003  MIOPEN_ATTR_TENSOR_STRIDES = 903,

7004  MIOPEN_ATTR_TENSOR_VECTOR_COUNT = 904,

7005  MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,

7006  MIOPEN_ATTR_TENSOR_UNIQUE_ID = 906,

7007  MIOPEN_ATTR_TENSOR_IS_VIRTUAL = 907,

7008  MIOPEN_ATTR_TENSOR_IS_BY_VALUE = 908,

7009  MIOPEN_ATTR_TENSOR_REORDERING_MODE = 909,

7010  MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC = 910,

7011 

7012  MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS = 1000,

7013  MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,

7014  MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,

7015  MIOPEN_ATTR_VARIANT_PACK_WORKSPACE = 1003,

7016 

7017  MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,

7018  MIOPEN_ATTR_LAYOUT_INFO_TYPES = 1101,

7019 

7020  MIOPEN_ATTR_KNOB_INFO_TYPE = 1200,

7021  MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,

7022  MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,

7023  MIOPEN_ATTR_KNOB_INFO_STRIDE = 1203,

7024 

7025  MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,

7026  MIOPEN_ATTR_ENGINE_GLOBAL_INDEX = 1301,

7027  MIOPEN_ATTR_ENGINE_KNOB_INFO = 1302,

7028  MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE = 1303,

7029  MIOPEN_ATTR_ENGINE_LAYOUT_INFO = 1304,

7030  MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE = 1305,

7031  MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,

7032 

7033  MIOPEN_ATTR_MATMUL_COMP_TYPE = 1500,

7034  MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,

7035 

7036  MIOPEN_ATTR_OPERATION_MATMUL_ADESC = 1520,

7037  MIOPEN_ATTR_OPERATION_MATMUL_BDESC = 1521,

7038  MIOPEN_ATTR_OPERATION_MATMUL_CDESC = 1522,

7039  MIOPEN_ATTR_OPERATION_MATMUL_DESC = 1523,

7040  MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,

7041  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC = 1525,

7042  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC = 1526,

7043  MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC = 1527,

7044 

7045  MIOPEN_ATTR_REDUCTION_OPERATOR = 1600,

7046  MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,

7047 

7048  MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,

7049  MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,

7050  MIOPEN_ATTR_OPERATION_REDUCTION_DESC = 1612,

7051 

7052  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC = 1620,

7053  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC = 1621,

7054  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC = 1622,

7055  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC = 1623,

7056  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC = 1624,

7057  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC = 1625,

7058  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC = 1626,

7059  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC = 1627,

7060  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,

7061  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC = 1629,

7062  MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS = 1630,

7063 

7064  MIOPEN_ATTR_RESAMPLE_MODE = 1700,

7065  MIOPEN_ATTR_RESAMPLE_COMP_TYPE = 1701,

7066  MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS = 1702,

7067  MIOPEN_ATTR_RESAMPLE_POST_PADDINGS = 1703,

7068  MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS = 1704,

7069  MIOPEN_ATTR_RESAMPLE_STRIDES = 1705,

7070  MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS = 1706,

7071  MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,

7072  MIOPEN_ATTR_RESAMPLE_PADDING_MODE = 1708,

7073 

7074  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC = 1710,

7075  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC = 1711,

7076  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,

7077  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA = 1713,

7078  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA = 1714,

7079  MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC = 1716,

7080 

7081  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC = 1720,

7082  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC = 1721,

7083  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,

7084  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA = 1723,

7085  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA = 1724,

7086  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC = 1725,

7087  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC = 1726,

7088  MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC = 1727,

7089 

7090  MIOPEN_ATTR_OPERATION_CONCAT_AXIS = 1800,

7091  MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS = 1801,

7092  MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,

7093  MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC = 1803,

7094 

7095  MIOPEN_ATTR_OPERATION_SIGNAL_MODE = 1900,

7096  MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,

7097  MIOPEN_ATTR_OPERATION_SIGNAL_VALUE = 1902,

7098  MIOPEN_ATTR_OPERATION_SIGNAL_XDESC = 1903,

7099  MIOPEN_ATTR_OPERATION_SIGNAL_YDESC = 1904,

7100 

7101  MIOPEN_ATTR_OPERATION_NORM_FWD_MODE = 2000,

7102  MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE = 2001,

7103  MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC = 2002,

7104  MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC = 2003,

7105  MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC = 2004,

7106  MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC = 2005,

7107  MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC = 2006,

7108  MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC = 2007,

7109  MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC = 2008,

7110  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC = 2009,

7111  MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC = 2010,

7112  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,

7113  MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC = 2012,

7114  MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC = 2013,

7115  MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS = 2014,

7116 

7117  MIOPEN_ATTR_OPERATION_NORM_BWD_MODE = 2100,

7118  MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC = 2101,

7119  MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC = 2102,

7120  MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,

7121  MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC = 2104,

7122  MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC = 2105,

7123  MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC = 2106,

7124  MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC = 2107,

7125  MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC = 2108,

7126  MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC = 2109,

7127  MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS = 2110,

7128 

7129  MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,

7130  MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,

7131 

7132  MIOPEN_ATTR_RNG_DISTRIBUTION = 2300,

7133  MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN = 2301,

7134  MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,

7135  MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM = 2303,

7136  MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM = 2304,

7137  MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY = 2305,

7138 

7139  MIOPEN_ATTR_OPERATION_RNG_YDESC = 2310,

7140  MIOPEN_ATTR_OPERATION_RNG_SEED = 2311,

7141  MIOPEN_ATTR_OPERATION_RNG_DESC = 2312,

7142  MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,

7143 

7144 } miopenBackendAttributeName_t;

7145 

7153 typedef enum

7154 {

7155  MIOPEN_TYPE_HANDLE = 0,

7156  MIOPEN_TYPE_DATA_TYPE,

7157  MIOPEN_TYPE_BOOLEAN,

7158  MIOPEN_TYPE_INT64,

7159  MIOPEN_TYPE_FLOAT,

7160  MIOPEN_TYPE_DOUBLE,

7161  MIOPEN_TYPE_VOID_PTR,

7162  MIOPEN_TYPE_CONVOLUTION_MODE,

7163  MIOPEN_TYPE_HEUR_MODE,

7164  MIOPEN_TYPE_KNOB_TYPE,

7165  MIOPEN_TYPE_NAN_PROPOGATION,

7166  MIOPEN_TYPE_NUMERICAL_NOTE,

7167  MIOPEN_TYPE_LAYOUT_TYPE,

7168  MIOPEN_TYPE_ATTRIB_NAME,

7169  MIOPEN_TYPE_POINTWISE_MODE,

7170  MIOPEN_TYPE_BACKEND_DESCRIPTOR,

7171  MIOPEN_TYPE_GENSTATS_MODE,

7172  MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,

7173  MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE,

7174  MIOPEN_TYPE_BEHAVIOR_NOTE,

7175  MIOPEN_TYPE_TENSOR_REORDERING_MODE,

7176  MIOPEN_TYPE_RESAMPLE_MODE,

7177  MIOPEN_TYPE_PADDING_MODE,

7178  MIOPEN_TYPE_INT32,

7179  MIOPEN_TYPE_CHAR,

7180  MIOPEN_TYPE_SIGNAL_MODE,

7181  MIOPEN_TYPE_FRACTION,

7182  MIOPEN_TYPE_NORM_MODE,

7183  MIOPEN_TYPE_NORM_FWD_PHASE,

7184  MIOPEN_TYPE_RNG_DISTRIBUTION

7185 } miopenBackendAttributeType_t;

7186 

7192 typedef enum

7193 {

7195  MIOPEN_POINTWISE_ADD,

7196 

7199  MIOPEN_POINTWISE_ADD_SQUARE,

7200 

7202  MIOPEN_POINTWISE_DIV,

7203 

7205  MIOPEN_POINTWISE_MAX,

7206 

7208  MIOPEN_POINTWISE_MIN,

7209 

7212  MIOPEN_POINTWISE_MOD,

7213 

7215  MIOPEN_POINTWISE_MUL,

7216 

7218  MIOPEN_POINTWISE_POW,

7219 

7221  MIOPEN_POINTWISE_SUB,

7222 

7224  MIOPEN_POINTWISE_ABS,

7225 

7227  MIOPEN_POINTWISE_CEIL,

7228 

7230  MIOPEN_POINTWISE_COS,

7231 

7233  MIOPEN_POINTWISE_EXP,

7234 

7236  MIOPEN_POINTWISE_FLOOR,

7237 

7239  MIOPEN_POINTWISE_LOG,

7240 

7242  MIOPEN_POINTWISE_NEG,

7243 

7245  MIOPEN_POINTWISE_RSQRT,

7246 

7248  MIOPEN_POINTWISE_SIN,

7249 

7251  MIOPEN_POINTWISE_SQRT,

7252 

7254  MIOPEN_POINTWISE_TAN,

7255 

7257  MIOPEN_POINTWISE_ERF,

7258 

7262  MIOPEN_POINTWISE_IDENTITY,

7263 

7265  MIOPEN_POINTWISE_RELU_FWD,

7266 

7268  MIOPEN_POINTWISE_TANH_FWD,

7269 

7271  MIOPEN_POINTWISE_SIGMOID_FWD,

7272 

7274  MIOPEN_POINTWISE_ELU_FWD,

7275 

7278  MIOPEN_POINTWISE_GELU_FWD,

7279 

7281  MIOPEN_POINTWISE_SOFTPLUS_FWD,

7282 

7284  MIOPEN_POINTWISE_SWISH_FWD,

7285 

7289  MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,

7290 

7293  MIOPEN_POINTWISE_RELU_BWD,

7294 

7296  MIOPEN_POINTWISE_TANH_BWD,

7297 

7299  MIOPEN_POINTWISE_SIGMOID_BWD,

7300 

7303  MIOPEN_POINTWISE_ELU_BWD,

7304 

7307  MIOPEN_POINTWISE_GELU_BWD,

7308 

7310  MIOPEN_POINTWISE_SOFTPLUS_BWD,

7311 

7313  MIOPEN_POINTWISE_SWISH_BWD,

7314 

7320  MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,

7321 

7323  MIOPEN_POINTWISE_CMP_EQ,

7324 

7326  MIOPEN_POINTWISE_CMP_NEQ,

7327 

7329  MIOPEN_POINTWISE_CMP_GT,

7330 

7333  MIOPEN_POINTWISE_CMP_GE,

7334 

7336  MIOPEN_POINTWISE_CMP_LT,

7337 

7340  MIOPEN_POINTWISE_CMP_LE,

7341 

7343  MIOPEN_POINTWISE_LOGICAL_AND,

7344 

7346  MIOPEN_POINTWISE_LOGICAL_OR,

7347 

7349  MIOPEN_POINTWISE_LOGICAL_NOT,

7350 

7352  MIOPEN_POINTWISE_GEN_INDEX,

7353 

7356  MIOPEN_POINTWISE_BINARY_SELECT,

7357 

7360  MIOPEN_POINTWISE_RECIPROCAL

7361 } miopenPointwiseMode_t;

7362 

7368 typedef enum

7369 {

7370  MIOPEN_RNG_DISTRIBUTION_BERNOULLI,

7371  MIOPEN_RNG_DISTRIBUTION_UNIFORM,

7372  MIOPEN_RNG_DISTRIBUTION_NORMAL,

7373 } miopenRngDistribution_t;

7374 

7375 typedef enum

7376 {

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

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

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

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

7381 

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

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

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

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

7386  But used to check for errors.*/

7387 } miopenAlphaBetaCase_t;

7392 typedef enum

7393 {

7394  MIOPEN_HEUR_MODE_INSTANT = 0,

7395  MIOPEN_HEUR_MODE_B = 1,

7396  MIOPEN_HEUR_MODE_FALLBACK = 2,

7397  MIOPEN_HEUR_MODE_A = 3,

7398  MIOPEN_HEUR_MODES_COUNT = 4,

7399 } miopenBackendHeurMode_t;

7400 

7413 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)

7414 

7415 

7428 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(

7429  miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);

7430 

7460 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,

7461  miopenBackendAttributeName_t attributeName,

7462  miopenBackendAttributeType_t attributeType,

7463  int64_t elementCount,

7464  void* arrayOfElements);

7465 

7482 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);

7483 

7518 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,

7519  miopenBackendAttributeName_t attributeName,

7520  miopenBackendAttributeType_t attributeType,

7521  int64_t requestedElementCount,

7522  int64_t* elementCount,

7523  void* arrayOfElements);

7524 

7544 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,

7545  miopenBackendDescriptor_t executionPlan,

7546  miopenBackendDescriptor_t variantPack);

7547 

7564 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);

7565 

7583 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,

7584  miopenBackendDescriptorType_t descriptorType,

7585  size_t sizeInBytes);

7586 

7588 // CLOSEOUT BackendAPI DOXYGEN GROUP

7589 #endif // MIOPEN_BETA_API

7590 

7591 #ifdef MIOPEN_BETA_API

7592 // FusedAdam APIs

7735 MIOPEN_EXPORT miopenStatus_t miopenFusedAdam(miopenHandle_t handle,

7736  const miopenTensorDescriptor_t paramDesc,

7737  void* param,

7738  const miopenTensorDescriptor_t gradDesc,

7739  const void* grad,

7740  const miopenTensorDescriptor_t expAvgDesc,

7741  void* expAvg,

7742  const miopenTensorDescriptor_t expAvgSqDesc,

7743  void* expAvgSq,

7744  const miopenTensorDescriptor_t maxExpAvgSqDesc,

7745  void* maxExpAvgSq,

7746  const miopenTensorDescriptor_t stateStepDesc,

7747  void* stateStep,

7748  const unsigned int state_step,

7749  const float lr,

7750  const float beta1,

7751  const float beta2,

7752  const float weight_decay,

7753  const float eps,

7754  const bool amsgrad,

7755  const bool maximize,

7756  const bool adamw,

7757  const miopenTensorDescriptor_t gradScaleDesc,

7758  const void* gradScale,

7759  const miopenTensorDescriptor_t foundInfDesc,

7760  const void* foundInf);

7761 

7902 MIOPEN_EXPORT miopenStatus_t

7903 miopenFusedAdamWithOutput(miopenHandle_t handle,

7904  const miopenTensorDescriptor_t paramInDesc,

7905  void* paramIn,

7906  const miopenTensorDescriptor_t paramOutDesc,

7907  void* paramOut,

7908  const miopenTensorDescriptor_t paramOutFloat16Desc,

7909  void* paramOutFloat16,

7910  const miopenTensorDescriptor_t gradInDesc,

7911  const void* gradIn,

7912  const miopenTensorDescriptor_t expAvgInDesc,

7913  void* expAvgIn,

7914  const miopenTensorDescriptor_t expAvgOutDesc,

7915  void* expAvgOut,

7916  const miopenTensorDescriptor_t expAvgSqInDesc,

7917  void* expAvgSqIn,

7918  const miopenTensorDescriptor_t expAvgSqOutDesc,

7919  void* expAvgSqOut,

7920  const miopenTensorDescriptor_t maxExpAvgSqInDesc,

7921  void* maxExpAvgSqIn,

7922  const miopenTensorDescriptor_t maxExpAvgSqOutDesc,

7923  void* maxExpAvgSqOut,

7924  const miopenTensorDescriptor_t stateStepInDesc,

7925  void* stateStepIn,

7926  const miopenTensorDescriptor_t stateStepOutDesc,

7927  void* stateStepOut,

7928  const unsigned int state_step,

7929  const float lr,

7930  const float beta1,

7931  const float beta2,

7932  const float weight_decay,

7933  const float eps,

7934  const bool amsgrad,

7935  const bool maximize,

7936  const bool adamw,

7937  const miopenTensorDescriptor_t gradScaleDesc,

7938  const void* gradScale,

7939  const miopenTensorDescriptor_t foundInfDesc,

7940  const void* foundInf);

7941 

7943 // CLOSEOUT SGD DOXYGEN GROUP

7944 #endif // MIOPEN_BETA_API

7945 

7946 #ifdef MIOPEN_BETA_API

7947 // TransformersAdamW APIs

8038 MIOPEN_EXPORT miopenStatus_t miopenTransformersAdamW(miopenHandle_t handle,

8039  const miopenTensorDescriptor_t paramDesc,

8040  void* param,

8041  const miopenTensorDescriptor_t gradDesc,

8042  const void* grad,

8043  const miopenTensorDescriptor_t expAvgDesc,

8044  void* expAvg,

8045  const miopenTensorDescriptor_t expAvgSqDesc,

8046  void* expAvgSq,

8047  const miopenTensorDescriptor_t stateStepDesc,

8048  void* stateStep,

8049  const unsigned int state_step,

8050  const float lr,

8051  const float beta1,

8052  const float beta2,

8053  const float weight_decay,

8054  const float eps,

8055  const bool correct_bias,

8056  const miopenTensorDescriptor_t gradScaleDesc,

8057  const void* gradScale,

8058  const miopenTensorDescriptor_t foundInfDesc,

8059  const void* foundInf);

8060 

8187 MIOPEN_EXPORT miopenStatus_t

8188 miopenTransformersAdamWWithOutput(miopenHandle_t handle,

8189  const miopenTensorDescriptor_t paramInDesc,

8190  void* paramIn,

8191  const miopenTensorDescriptor_t paramOutDesc,

8192  void* paramOut,

8193  const miopenTensorDescriptor_t paramOutFloat16Desc,

8194  void* paramOutFloat16,

8195  const miopenTensorDescriptor_t gradInDesc,

8196  const void* gradIn,

8197  const miopenTensorDescriptor_t expAvgInDesc,

8198  void* expAvgIn,

8199  const miopenTensorDescriptor_t expAvgOutDesc,

8200  void* expAvgOut,

8201  const miopenTensorDescriptor_t expAvgSqInDesc,

8202  void* expAvgSqIn,

8203  const miopenTensorDescriptor_t expAvgSqOutDesc,

8204  void* expAvgSqOut,

8205  const miopenTensorDescriptor_t stateStepInDesc,

8206  void* stateStepIn,

8207  const miopenTensorDescriptor_t stateStepOutDesc,

8208  void* stateStepOut,

8209  const unsigned int state_step,

8210  const float lr,

8211  const float beta1,

8212  const float beta2,

8213  const float weight_decay,

8214  const float eps,

8215  const float step_size,

8216  const bool correct_bias,

8217  const miopenTensorDescriptor_t gradScaleDesc,

8218  const void* gradScale,

8219  const miopenTensorDescriptor_t foundInfDesc,

8220  const void* foundInf);

8221 

8223 // CLOSEOUT SGD DOXYGEN GROUP

8224 #endif // MIOPEN_BETA_API

8225 

8226 #ifdef MIOPEN_BETA_API

8227 // GetItem APIs

8240 MIOPEN_EXPORT miopenStatus_t

8241 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,

8242  uint32_t indexCount,

8243  const miopenTensorDescriptor_t* indexDescs,

8244  size_t* sizeInBytes);

8245 

8270 MIOPEN_EXPORT miopenStatus_t miopenGetitemBackward(miopenHandle_t handle,

8271  void* workspace,

8272  size_t workspaceSizeInBytes,

8273  const miopenTensorDescriptor_t dyDesc,

8274  const void* dy,

8275  uint32_t indexCount,

8276  const miopenTensorDescriptor_t* indexDescs,

8277  const void* const* indexs,

8278  const miopenTensorDescriptor_t dxDesc,

8279  void* dx,

8280  const miopenTensorDescriptor_t errorDesc,

8281  void* error,

8282  uint32_t dimCount,

8283  const int32_t* dims,

8284  uint32_t sliceCount,

8285  const int32_t* slices,

8286  uint32_t offset);

8287 

8289 // CLOSEOUT GETITEM DOXYGEN GROUP

8290 #endif // MIOPEN_BETA_API

8291 

8292 #ifdef MIOPEN_BETA_API

8293 // RotaryPositionalEmbeddings APIs

8311 MIOPEN_EXPORT miopenStatus_t miopenRoPEForward(miopenHandle_t handle,

8312  const miopenTensorDescriptor_t xDesc,

8313  const void* x,

8314  const miopenTensorDescriptor_t cosDesc,

8315  const void* cos,

8316  const miopenTensorDescriptor_t sinDesc,

8317  const void* sin,

8318  const miopenTensorDescriptor_t yDesc,

8319  void* y);

8320 

8334 MIOPEN_EXPORT miopenStatus_t miopenRoPEBackward(miopenHandle_t handle,

8335  const miopenTensorDescriptor_t dyDesc,

8336  const void* dy,

8337  const miopenTensorDescriptor_t cosDesc,

8338  const void* cos,

8339  const miopenTensorDescriptor_t sinDesc,

8340  const void* sin,

8341  const miopenTensorDescriptor_t dxDesc,

8342  void* dx);

8344 // CLOSEOUT ROPE DOXYGEN GROUP

8345 // kthvalue APIs

8366 MIOPEN_EXPORT miopenStatus_t miopenKthvalueForward(miopenHandle_t handle,

8367  miopenTensorDescriptor_t inputDesc,

8368  const void* input,

8369  miopenTensorDescriptor_t outputDesc,

8370  void* output,

8371  miopenTensorDescriptor_t indicesDesc,

8372  size_t* indices,

8373  size_t k,

8374  int32_t dim = -1,

8375  bool keepDim = false);

8376 

8378 // CLOSEOUT kthvalue DOXYGEN GROUP

8379 #endif // MIOPEN_BETA_API

8380 

8381 #ifdef MIOPEN_BETA_API

8395 MIOPEN_EXPORT miopenStatus_t

8396 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,

8397  miopenTensorDescriptor_t inputDesc,

8398  miopenTensorDescriptor_t weightDesc,

8399  size_t* sizeInBytes);

8400 

8417 MIOPEN_EXPORT miopenStatus_t miopenPReLUBackward(miopenHandle_t handle,

8418  void* workspace,

8419  size_t workspaceSizeInBytes,

8420  miopenTensorDescriptor_t inputDesc,

8421  const void* input,

8422  miopenTensorDescriptor_t weightDesc,

8423  const void* weight,

8424  miopenTensorDescriptor_t doutputDesc,

8425  const void* doutput,

8426  miopenTensorDescriptor_t dinputDesc,

8427  void* dinput,

8428  miopenTensorDescriptor_t dweightDesc,

8429  void* dweight);

8430 

8432 // CLOSEOUT RELU DOXYGEN GROUP

8433 #endif // MIOPEN_BETA_API

8434 

8435 #ifdef MIOPEN_BETA_API

8436 

8441 typedef enum

8442 {

8443  MIOPEN_LOSS_REDUCTION_NONE = 0,

8444  MIOPEN_LOSS_REDUCTION_SUM = 1,

8445  MIOPEN_LOSS_REDUCTION_MEAN = 2,

8447 } miopenLossReductionMode_t;

8448 

8449 // SoftMarginLoss APIs

8467 MIOPEN_EXPORT miopenStatus_t

8468 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8469  miopenTensorDescriptor_t inputDesc,

8470  miopenTensorDescriptor_t targetDesc,

8471  miopenTensorDescriptor_t outputDesc,

8472  miopenLossReductionMode_t reduction,

8473  size_t* sizeInBytes);

8474 

8491 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossForward(miopenHandle_t handle,

8492  miopenTensorDescriptor_t inputDesc,

8493  const void* input,

8494  miopenTensorDescriptor_t targetDesc,

8495  const void* target,

8496  miopenTensorDescriptor_t outputDesc,

8497  void* output,

8498  miopenLossReductionMode_t reduction,

8499  void* workspace = nullptr,

8500  size_t workspaceSizeInBytes = 0);

8501 

8516 MIOPEN_EXPORT miopenStatus_t miopenSoftMarginLossBackward(miopenHandle_t handle,

8517  miopenTensorDescriptor_t inputDesc,

8518  const void* input,

8519  miopenTensorDescriptor_t targetDesc,

8520  const void* target,

8521  miopenTensorDescriptor_t doutputDesc,

8522  const void* doutput,

8523  miopenTensorDescriptor_t dinputDesc,

8524  void* dinput,

8525  miopenLossReductionMode_t reduction);

8526 

8528 // CLOSEOUT LossFunction DOXYGEN GROUP

8529 #endif

8530 

8531 #ifdef MIOPEN_BETA_API

8532 // MultiMarginLoss APIs

8556 MIOPEN_EXPORT miopenStatus_t

8557 miopenGetMultiMarginLossForwardWorkspaceSize(miopenHandle_t handle,

8558  miopenTensorDescriptor_t inputDesc,

8559  miopenTensorDescriptor_t targetDesc,

8560  miopenTensorDescriptor_t weightDesc,

8561  miopenTensorDescriptor_t outputDesc,

8562  long p,

8563  float margin,

8564  miopenLossReductionMode_t reduction,

8565  size_t* sizeInBytes);

8566 

8594 MIOPEN_EXPORT miopenStatus_t miopenMultiMarginLossForward(miopenHandle_t handle,

8595  miopenTensorDescriptor_t inputDesc,

8596  const void* input,

8597  miopenTensorDescriptor_t targetDesc,

8598  const void* target,

8599  miopenTensorDescriptor_t weightDesc,

8600  const void* weight,

8601  miopenTensorDescriptor_t outputDesc,

8602  void* output,

8603  long p,

8604  float margin,

8605  miopenLossReductionMode_t reduction,

8606  void* workspace,

8607  size_t workspaceSizeInBytes);

8608 

8610 // CLOSEOUT LossFunction DOXYGEN GROUP

8611 #endif // MIOPEN_BETA_API

8612 

8624 typedef enum

8625 {

8626  miopenTuningPolicyNone = 1,

8627  miopenTuningPolicyDbUpdate = 2,

8628  miopenTuningPolicySearch = 3,

8629  miopenTuningPolicySearchDbUpdate = 4,

8630  miopenTuningPolicyDbClean = 5,

8631 } miopenTuningPolicy_t;

8632 

8641 MIOPEN_EXPORT miopenStatus_t miopenSetTuningPolicy(miopenHandle_t handle,

8642  miopenTuningPolicy_t newValue);

8643 

8651 MIOPEN_EXPORT miopenStatus_t miopenGetTuningPolicy(miopenHandle_t handle,

8652  miopenTuningPolicy_t* value);

8653 

8654 #ifdef __cplusplus

8655 }

8656 #endif

8657 

8658 #ifdef __clang__

8659 #pragma clang diagnostic pop

8660 #endif

8661 

8662 #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:3699

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

miopenVerticalFusion

@ miopenVerticalFusion

Definition: miopen.h:3700

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

miopenPointwiseMode_t

miopenPointwiseMode_t

Intended pointwise math operation for a pointwise operation descriptor.

Definition: miopen.h:7193

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

miopenRngDistribution_t

miopenRngDistribution_t

Distribution for random number generation.

Definition: miopen.h:7369

miopenBackendDescriptorType_t

miopenBackendDescriptorType_t

Descriptor type.

Definition: miopen.h:6857

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

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

MIOPEN_HEUR_MODE_INSTANT

@ MIOPEN_HEUR_MODE_INSTANT

Definition: miopen.h:7394

MIOPEN_HEUR_MODE_A

@ MIOPEN_HEUR_MODE_A

Definition: miopen.h:7397

MIOPEN_HEUR_MODE_B

@ MIOPEN_HEUR_MODE_B

Definition: miopen.h:7395

MIOPEN_HEUR_MODES_COUNT

@ MIOPEN_HEUR_MODES_COUNT

Definition: miopen.h:7398

MIOPEN_HEUR_MODE_FALLBACK

@ MIOPEN_HEUR_MODE_FALLBACK

Definition: miopen.h:7396

MIOPEN_POINTWISE_SOFTPLUS_FWD

@ MIOPEN_POINTWISE_SOFTPLUS_FWD

Definition: miopen.h:7281

MIOPEN_POINTWISE_ELU_FWD

@ MIOPEN_POINTWISE_ELU_FWD

Definition: miopen.h:7274

MIOPEN_POINTWISE_RELU_FWD

@ MIOPEN_POINTWISE_RELU_FWD

Definition: miopen.h:7265

MIOPEN_POINTWISE_DIV

@ MIOPEN_POINTWISE_DIV

Definition: miopen.h:7202

MIOPEN_POINTWISE_SIGMOID_BWD

@ MIOPEN_POINTWISE_SIGMOID_BWD

Definition: miopen.h:7299

MIOPEN_POINTWISE_POW

@ MIOPEN_POINTWISE_POW

Definition: miopen.h:7218

MIOPEN_POINTWISE_MOD

@ MIOPEN_POINTWISE_MOD

Definition: miopen.h:7212

MIOPEN_POINTWISE_SQRT

@ MIOPEN_POINTWISE_SQRT

Definition: miopen.h:7251

MIOPEN_POINTWISE_BINARY_SELECT

@ MIOPEN_POINTWISE_BINARY_SELECT

Definition: miopen.h:7356

MIOPEN_POINTWISE_GELU_BWD

@ MIOPEN_POINTWISE_GELU_BWD

Definition: miopen.h:7307

MIOPEN_POINTWISE_MIN

@ MIOPEN_POINTWISE_MIN

Definition: miopen.h:7208

MIOPEN_POINTWISE_CMP_NEQ

@ MIOPEN_POINTWISE_CMP_NEQ

Definition: miopen.h:7326

MIOPEN_POINTWISE_FLOOR

@ MIOPEN_POINTWISE_FLOOR

Definition: miopen.h:7236

MIOPEN_POINTWISE_RSQRT

@ MIOPEN_POINTWISE_RSQRT

Definition: miopen.h:7245

MIOPEN_POINTWISE_CMP_EQ

@ MIOPEN_POINTWISE_CMP_EQ

Definition: miopen.h:7323

MIOPEN_POINTWISE_CMP_GE

@ MIOPEN_POINTWISE_CMP_GE

Definition: miopen.h:7333

MIOPEN_POINTWISE_ADD_SQUARE

@ MIOPEN_POINTWISE_ADD_SQUARE

Definition: miopen.h:7199

MIOPEN_POINTWISE_ERF

@ MIOPEN_POINTWISE_ERF

Definition: miopen.h:7257

MIOPEN_POINTWISE_SWISH_FWD

@ MIOPEN_POINTWISE_SWISH_FWD

Definition: miopen.h:7284

MIOPEN_POINTWISE_LOG

@ MIOPEN_POINTWISE_LOG

Definition: miopen.h:7239

MIOPEN_POINTWISE_SUB

@ MIOPEN_POINTWISE_SUB

Definition: miopen.h:7221

MIOPEN_POINTWISE_NEG

@ MIOPEN_POINTWISE_NEG

Definition: miopen.h:7242

MIOPEN_POINTWISE_LOGICAL_AND

@ MIOPEN_POINTWISE_LOGICAL_AND

Definition: miopen.h:7343

MIOPEN_POINTWISE_SWISH_BWD

@ MIOPEN_POINTWISE_SWISH_BWD

Definition: miopen.h:7313

MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD

Definition: miopen.h:7289

MIOPEN_POINTWISE_SIN

@ MIOPEN_POINTWISE_SIN

Definition: miopen.h:7248

MIOPEN_POINTWISE_RECIPROCAL

@ MIOPEN_POINTWISE_RECIPROCAL

Definition: miopen.h:7360

MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

@ MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD

Definition: miopen.h:7320

MIOPEN_POINTWISE_GELU_FWD

@ MIOPEN_POINTWISE_GELU_FWD

Definition: miopen.h:7278

MIOPEN_POINTWISE_ABS

@ MIOPEN_POINTWISE_ABS

Definition: miopen.h:7224

MIOPEN_POINTWISE_CMP_LT

@ MIOPEN_POINTWISE_CMP_LT

Definition: miopen.h:7336

MIOPEN_POINTWISE_EXP

@ MIOPEN_POINTWISE_EXP

Definition: miopen.h:7233

MIOPEN_POINTWISE_GEN_INDEX

@ MIOPEN_POINTWISE_GEN_INDEX

Definition: miopen.h:7352

MIOPEN_POINTWISE_CEIL

@ MIOPEN_POINTWISE_CEIL

Definition: miopen.h:7227

MIOPEN_POINTWISE_LOGICAL_NOT

@ MIOPEN_POINTWISE_LOGICAL_NOT

Definition: miopen.h:7349

MIOPEN_POINTWISE_SIGMOID_FWD

@ MIOPEN_POINTWISE_SIGMOID_FWD

Definition: miopen.h:7271

MIOPEN_POINTWISE_SOFTPLUS_BWD

@ MIOPEN_POINTWISE_SOFTPLUS_BWD

Definition: miopen.h:7310

MIOPEN_POINTWISE_LOGICAL_OR

@ MIOPEN_POINTWISE_LOGICAL_OR

Definition: miopen.h:7346

MIOPEN_POINTWISE_TAN

@ MIOPEN_POINTWISE_TAN

Definition: miopen.h:7254

MIOPEN_POINTWISE_ELU_BWD

@ MIOPEN_POINTWISE_ELU_BWD

Definition: miopen.h:7303

MIOPEN_POINTWISE_IDENTITY

@ MIOPEN_POINTWISE_IDENTITY

Definition: miopen.h:7262

MIOPEN_POINTWISE_CMP_LE

@ MIOPEN_POINTWISE_CMP_LE

Definition: miopen.h:7340

MIOPEN_POINTWISE_COS

@ MIOPEN_POINTWISE_COS

Definition: miopen.h:7230

MIOPEN_POINTWISE_TANH_BWD

@ MIOPEN_POINTWISE_TANH_BWD

Definition: miopen.h:7296

MIOPEN_POINTWISE_MUL

@ MIOPEN_POINTWISE_MUL

Definition: miopen.h:7215

MIOPEN_POINTWISE_TANH_FWD

@ MIOPEN_POINTWISE_TANH_FWD

Definition: miopen.h:7268

MIOPEN_POINTWISE_RELU_BWD

@ MIOPEN_POINTWISE_RELU_BWD

Definition: miopen.h:7293

MIOPEN_POINTWISE_ADD

@ MIOPEN_POINTWISE_ADD

Definition: miopen.h:7195

MIOPEN_POINTWISE_MAX

@ MIOPEN_POINTWISE_MAX

Definition: miopen.h:7205

MIOPEN_POINTWISE_CMP_GT

@ MIOPEN_POINTWISE_CMP_GT

Definition: miopen.h:7329

MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MODE

Definition: miopen.h:7117

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W

Definition: miopen.h:6947

MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

@ MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION

Definition: miopen.h:7071

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC

Definition: miopen.h:7074

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W

Definition: miopen.h:6953

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA

Definition: miopen.h:6944

MIOPEN_ATTR_OPERATION_SIGNAL_MODE

@ MIOPEN_ATTR_OPERATION_SIGNAL_MODE

Definition: miopen.h:7095

MIOPEN_ATTR_OPERATION_RNG_DESC

@ MIOPEN_ATTR_OPERATION_RNG_DESC

Definition: miopen.h:7141

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA

Definition: miopen.h:6945

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC

Definition: miopen.h:7058

MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC

Definition: miopen.h:7120

MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC

Definition: miopen.h:7108

MIOPEN_ATTR_OPERATIONGRAPH_OPS

@ MIOPEN_ATTR_OPERATIONGRAPH_OPS

Definition: miopen.h:6997

MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE

Definition: miopen.h:7021

MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS

Definition: miopen.h:6916

MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_YDESC

Definition: miopen.h:7099

MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC

Definition: miopen.h:7124

MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS

Definition: miopen.h:7127

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC

Definition: miopen.h:7088

MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

@ MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS

Definition: miopen.h:6917

MIOPEN_ATTR_REDUCTION_OPERATOR

@ MIOPEN_ATTR_REDUCTION_OPERATOR

Definition: miopen.h:7045

MIOPEN_ATTR_OPERATION_MATMUL_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_DESC

Definition: miopen.h:7039

MIOPEN_ATTR_CONVOLUTION_DILATIONS

@ MIOPEN_ATTR_CONVOLUTION_DILATIONS

Definition: miopen.h:6914

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC

Definition: miopen.h:7082

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1

Definition: miopen.h:6966

MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

@ MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS

Definition: miopen.h:7066

MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS

Definition: miopen.h:6932

MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC

Definition: miopen.h:7104

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC

Definition: miopen.h:6986

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC

Definition: miopen.h:7054

MIOPEN_ATTR_KNOB_INFO_TYPE

@ MIOPEN_ATTR_KNOB_INFO_TYPE

Definition: miopen.h:7020

MIOPEN_ATTR_LAYOUT_INFO_TYPES

@ MIOPEN_ATTR_LAYOUT_INFO_TYPES

Definition: miopen.h:7018

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC

Definition: miopen.h:6980

MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

@ MIOPEN_ATTR_OPERATIONGRAPH_HANDLE

Definition: miopen.h:6996

MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC

Definition: miopen.h:7121

MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM

Definition: miopen.h:7136

MIOPEN_ATTR_POINTWISE_MATH_PREC

@ MIOPEN_ATTR_POINTWISE_MATH_PREC

Definition: miopen.h:6902

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC

Definition: miopen.h:7042

MIOPEN_ATTR_OPERATION_GENSTATS_MODE

@ MIOPEN_ATTR_OPERATION_GENSTATS_MODE

Definition: miopen.h:6972

MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE

Definition: miopen.h:6942

MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

@ MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES

Definition: miopen.h:7014

MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_YDESC

Definition: miopen.h:7049

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA

Definition: miopen.h:6957

MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

@ MIOPEN_ATTR_VARIANT_PACK_WORKSPACE

Definition: miopen.h:7015

MIOPEN_ATTR_TENSOR_IS_BY_VALUE

@ MIOPEN_ATTR_TENSOR_IS_BY_VALUE

Definition: miopen.h:7008

MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_MODE

Definition: miopen.h:7101

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC

Definition: miopen.h:6946

MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE

Definition: miopen.h:6978

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC

Definition: miopen.h:7111

MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_XDESC

Definition: miopen.h:7129

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC

Definition: miopen.h:7087

MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_XDESC

Definition: miopen.h:6963

MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

@ MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS

Definition: miopen.h:7012

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC

Definition: miopen.h:7057

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA

Definition: miopen.h:7077

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC

Definition: miopen.h:6982

MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

@ MIOPEN_ATTR_OPERATION_SIGNAL_VALUE

Definition: miopen.h:7097

MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC

Definition: miopen.h:7096

MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_TDESC

Definition: miopen.h:6970

MIOPEN_ATTR_ENGINEHEUR_RESULTS

@ MIOPEN_ATTR_ENGINEHEUR_RESULTS

Definition: miopen.h:6922

MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

@ MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT

Definition: miopen.h:7000

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X

Definition: miopen.h:6960

MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC

Definition: miopen.h:6992

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS

Definition: miopen.h:7062

MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC

Definition: miopen.h:6973

MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7110

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC

Definition: miopen.h:6990

MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

@ MIOPEN_ATTR_EXECUTION_PLAN_HANDLE

Definition: miopen.h:6929

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC

Definition: miopen.h:7056

MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

@ MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC

Definition: miopen.h:7093

MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC

Definition: miopen.h:7123

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA

Definition: miopen.h:6951

MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

@ MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE

Definition: miopen.h:6931

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX

Definition: miopen.h:6954

MIOPEN_ATTR_TENSOR_VECTOR_COUNT

@ MIOPEN_ATTR_TENSOR_VECTOR_COUNT

Definition: miopen.h:7004

MIOPEN_ATTR_OPERATION_MATMUL_CDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_CDESC

Definition: miopen.h:7038

MIOPEN_ATTR_REDUCTION_COMP_TYPE

@ MIOPEN_ATTR_REDUCTION_COMP_TYPE

Definition: miopen.h:7046

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA

Definition: miopen.h:7085

MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

@ MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION

Definition: miopen.h:7005

MIOPEN_ATTR_TENSOR_DIMENSIONS

@ MIOPEN_ATTR_TENSOR_DIMENSIONS

Definition: miopen.h:7002

MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC

Definition: miopen.h:6975

MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

@ MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX

Definition: miopen.h:7092

MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

@ MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2

Definition: miopen.h:6967

MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

@ MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE

Definition: miopen.h:7028

MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

@ MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE

Definition: miopen.h:7030

MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

@ MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION

Definition: miopen.h:6934

MIOPEN_ATTR_RESAMPLE_STRIDES

@ MIOPEN_ATTR_RESAMPLE_STRIDES

Definition: miopen.h:7069

MIOPEN_ATTR_POINTWISE_ELU_ALPHA

@ MIOPEN_ATTR_POINTWISE_ELU_ALPHA

Definition: miopen.h:6907

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC

Definition: miopen.h:7113

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC

Definition: miopen.h:7083

MIOPEN_ATTR_OPERATION_RNG_SEED

@ MIOPEN_ATTR_OPERATION_RNG_SEED

Definition: miopen.h:7140

MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC

Definition: miopen.h:7118

MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC

Definition: miopen.h:6968

MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

@ MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS

Definition: miopen.h:7091

MIOPEN_ATTR_RESAMPLE_MODE

@ MIOPEN_ATTR_RESAMPLE_MODE

Definition: miopen.h:7064

MIOPEN_ATTR_RNG_DISTRIBUTION

@ MIOPEN_ATTR_RNG_DISTRIBUTION

Definition: miopen.h:7132

MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC

Definition: miopen.h:7119

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC

Definition: miopen.h:7041

MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE

Definition: miopen.h:7102

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE

Definition: miopen.h:6906

MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

@ MIOPEN_ATTR_OPERATION_RESHAPE_YDESC

Definition: miopen.h:7130

MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

@ MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS

Definition: miopen.h:7013

MIOPEN_ATTR_POINTWISE_AXIS

@ MIOPEN_ATTR_POINTWISE_AXIS

Definition: miopen.h:6910

MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC

Definition: miopen.h:7114

MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP

Definition: miopen.h:6904

MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINE_OPERATION_GRAPH

Definition: miopen.h:7025

MIOPEN_ATTR_OPERATION_MATMUL_BDESC

@ MIOPEN_ATTR_OPERATION_MATMUL_BDESC

Definition: miopen.h:7037

MIOPEN_ATTR_TENSOR_DATA_TYPE

@ MIOPEN_ATTR_TENSOR_DATA_TYPE

Definition: miopen.h:7001

MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

@ MIOPEN_ATTR_OPERATION_SIGNAL_XDESC

Definition: miopen.h:7098

MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

@ MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE

Definition: miopen.h:7022

MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC

Definition: miopen.h:7107

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC

Definition: miopen.h:7079

MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS

Definition: miopen.h:7068

MIOPEN_ATTR_MATMUL_COMP_TYPE

@ MIOPEN_ATTR_MATMUL_COMP_TYPE

Definition: miopen.h:7033

MIOPEN_ATTR_TENSOR_UNIQUE_ID

@ MIOPEN_ATTR_TENSOR_UNIQUE_ID

Definition: miopen.h:7006

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC

Definition: miopen.h:7060

MIOPEN_ATTR_OPERATION_CONCAT_AXIS

@ MIOPEN_ATTR_OPERATION_CONCAT_AXIS

Definition: miopen.h:7090

MIOPEN_ATTR_OPERATION_RNG_YDESC

@ MIOPEN_ATTR_OPERATION_RNG_YDESC

Definition: miopen.h:7139

MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

@ MIOPEN_ATTR_ENGINE_GLOBAL_INDEX

Definition: miopen.h:7026

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC

Definition: miopen.h:6952

MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

@ MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH

Definition: miopen.h:6921

MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

@ MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC

Definition: miopen.h:7010

MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

@ MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA

Definition: miopen.h:6908

MIOPEN_ATTR_TENSOR_IS_VIRTUAL

@ MIOPEN_ATTR_TENSOR_IS_VIRTUAL

Definition: miopen.h:7007

MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

@ MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES

Definition: miopen.h:6927

MIOPEN_ATTR_MATMUL_PADDING_VALUE

@ MIOPEN_ATTR_MATMUL_PADDING_VALUE

Definition: miopen.h:7034

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC

Definition: miopen.h:6994

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC

Definition: miopen.h:6989

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X

Definition: miopen.h:6948

MIOPEN_ATTR_KNOB_INFO_STRIDE

@ MIOPEN_ATTR_KNOB_INFO_STRIDE

Definition: miopen.h:7023

MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

@ MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS

Definition: miopen.h:7070

MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_YDESC

Definition: miopen.h:6965

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC

Definition: miopen.h:7075

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC

Definition: miopen.h:7055

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY

Definition: miopen.h:6955

MIOPEN_ATTR_CONVOLUTION_CONV_MODE

@ MIOPEN_ATTR_CONVOLUTION_CONV_MODE

Definition: miopen.h:6913

MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_XDESC

Definition: miopen.h:7048

MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

@ MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS

Definition: miopen.h:6933

MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC

Definition: miopen.h:6979

MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET

Definition: miopen.h:7031

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC

Definition: miopen.h:6991

MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

@ MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE

Definition: miopen.h:6941

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC

Definition: miopen.h:7081

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC

Definition: miopen.h:6984

MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC

Definition: miopen.h:6969

MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC

Definition: miopen.h:7109

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC

Definition: miopen.h:7061

MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

@ MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC

Definition: miopen.h:7142

MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y

Definition: miopen.h:6949

MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC

Definition: miopen.h:6985

MIOPEN_ATTR_ENGINE_LAYOUT_INFO

@ MIOPEN_ATTR_ENGINE_LAYOUT_INFO

Definition: miopen.h:7029

MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

@ MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID

Definition: miopen.h:6936

MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

@ MIOPEN_ATTR_CONVOLUTION_COMP_TYPE

Definition: miopen.h:6912

MIOPEN_ATTR_RESAMPLE_COMP_TYPE

@ MIOPEN_ATTR_RESAMPLE_COMP_TYPE

Definition: miopen.h:7065

MIOPEN_ATTR_ENGINECFG_ENGINE

@ MIOPEN_ATTR_ENGINECFG_ENGINE

Definition: miopen.h:6925

MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

@ MIOPEN_ATTR_RESAMPLE_POST_PADDINGS

Definition: miopen.h:7067

MIOPEN_ATTR_RESAMPLE_PADDING_MODE

@ MIOPEN_ATTR_RESAMPLE_PADDING_MODE

Definition: miopen.h:7072

MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

@ MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS

Definition: miopen.h:6918

MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC

Definition: miopen.h:7112

MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_XDESC

Definition: miopen.h:6974

MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC

Definition: miopen.h:7105

MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC

Definition: miopen.h:6981

MIOPEN_ATTR_ENGINE_KNOB_INFO

@ MIOPEN_ATTR_ENGINE_KNOB_INFO

Definition: miopen.h:7027

MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

@ MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT

Definition: miopen.h:7040

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW

Definition: miopen.h:6959

MIOPEN_ATTR_TENSOR_REORDERING_MODE

@ MIOPEN_ATTR_TENSOR_REORDERING_MODE

Definition: miopen.h:7009

MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

@ MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE

Definition: miopen.h:6937

MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

@ MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC

Definition: miopen.h:7043

MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

@ MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR

Definition: miopen.h:6962

MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

@ MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION

Definition: miopen.h:7134

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS

Definition: miopen.h:6938

MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

@ MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID

Definition: miopen.h:7017

MIOPEN_ATTR_ENGINEHEUR_MODE

@ MIOPEN_ATTR_ENGINEHEUR_MODE

Definition: miopen.h:6920

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA

Definition: miopen.h:7084

MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC

Definition: miopen.h:7086

MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC

Definition: miopen.h:6993

MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

@ MIOPEN_ATTR_OPERATION_POINTWISE_BDESC

Definition: miopen.h:6964

MIOPEN_ATTR_POINTWISE_MODE

@ MIOPEN_ATTR_POINTWISE_MODE

Definition: miopen.h:6901

MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

@ MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO

Definition: miopen.h:6926

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY

Definition: miopen.h:6961

MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC

Definition: miopen.h:7126

MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

@ MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION

Definition: miopen.h:6903

MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

@ MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES

Definition: miopen.h:6939

MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

@ MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP

Definition: miopen.h:6905

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC

Definition: miopen.h:7059

MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

@ MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY

Definition: miopen.h:7137

MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

@ MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET

Definition: miopen.h:6923

MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC

Definition: miopen.h:6983

MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC

Definition: miopen.h:6987

MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

@ MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN

Definition: miopen.h:7133

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC

Definition: miopen.h:7052

MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC

Definition: miopen.h:7053

MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

@ MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS

Definition: miopen.h:7115

MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC

Definition: miopen.h:7106

MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

@ MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC

Definition: miopen.h:6976

MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

@ MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG

Definition: miopen.h:6930

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA

Definition: miopen.h:7078

MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC

Definition: miopen.h:7125

MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

@ MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC

Definition: miopen.h:7122

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA

Definition: miopen.h:6950

MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

@ MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM

Definition: miopen.h:7135

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC

Definition: miopen.h:6958

MIOPEN_ATTR_TENSOR_STRIDES

@ MIOPEN_ATTR_TENSOR_STRIDES

Definition: miopen.h:7003

MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

@ MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES

Definition: miopen.h:6915

MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

@ MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA

Definition: miopen.h:6956

MIOPEN_ATTR_POINTWISE_SWISH_BETA

@ MIOPEN_ATTR_POINTWISE_SWISH_BETA

Definition: miopen.h:6909

MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

@ MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC

Definition: miopen.h:7076

MIOPEN_ATTR_OPERATION_REDUCTION_DESC

@ MIOPEN_ATTR_OPERATION_REDUCTION_DESC

Definition: miopen.h:7050

MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

@ MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC

Definition: miopen.h:7103

MIOPEN_ATTR_OPERATION_MATMUL_ADESC

@ MIOPEN_ATTR_OPERATION_MATMUL_ADESC

Definition: miopen.h:7036

MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

@ MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT

Definition: miopen.h:6998

MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

@ MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC

Definition: miopen.h:6988

MIOPEN_RNG_DISTRIBUTION_BERNOULLI

@ MIOPEN_RNG_DISTRIBUTION_BERNOULLI

Definition: miopen.h:7370

MIOPEN_RNG_DISTRIBUTION_UNIFORM

@ MIOPEN_RNG_DISTRIBUTION_UNIFORM

Definition: miopen.h:7371

MIOPEN_RNG_DISTRIBUTION_NORMAL

@ MIOPEN_RNG_DISTRIBUTION_NORMAL

Definition: miopen.h:7372

MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR

Definition: miopen.h:6868

MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

@ MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR

Definition: miopen.h:6886

MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR

Definition: miopen.h:6860

MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_POINTWISE_DESCRIPTOR

Definition: miopen.h:6884

MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR

Definition: miopen.h:6879

MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

@ MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR

Definition: miopen.h:6858

MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR

Definition: miopen.h:6881

MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR

Definition: miopen.h:6865

MIOPEN_BACKEND_RNG_DESCRIPTOR

@ MIOPEN_BACKEND_RNG_DESCRIPTOR

Definition: miopen.h:6887

MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR

Definition: miopen.h:6876

MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR

Definition: miopen.h:6875

MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR

Definition: miopen.h:6861

MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR

Definition: miopen.h:6880

MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR

Definition: miopen.h:6866

MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR

Definition: miopen.h:6877

MIOPEN_BACKEND_TENSOR_DESCRIPTOR

@ MIOPEN_BACKEND_TENSOR_DESCRIPTOR

Definition: miopen.h:6888

MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR

Definition: miopen.h:6878

MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR

Definition: miopen.h:6883

MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR

Definition: miopen.h:6871

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR

Definition: miopen.h:6870

MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

@ MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR

Definition: miopen.h:6863

MIOPEN_BACKEND_ENGINE_DESCRIPTOR

@ MIOPEN_BACKEND_ENGINE_DESCRIPTOR

Definition: miopen.h:6859

MIOPEN_BACKEND_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_MATMUL_DESCRIPTOR

Definition: miopen.h:6867

MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR

Definition: miopen.h:6872

MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

@ MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR

Definition: miopen.h:6889

MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

@ MIOPEN_BACKEND_REDUCTION_DESCRIPTOR

Definition: miopen.h:6885

MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR

Definition: miopen.h:6869

MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR

Definition: miopen.h:6873

MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR

Definition: miopen.h:6874

MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

@ MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR

Definition: miopen.h:6882

MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

@ MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR

Definition: miopen.h:6862

MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

@ MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR

Definition: miopen.h:6864

SCALE

@ SCALE

Definition: miopen.h:7383

BILINEAR

@ BILINEAR

Definition: miopen.h:7384

DEFAULT

@ DEFAULT

Definition: miopen.h:7382

ERROR_STATE

@ ERROR_STATE

Definition: miopen.h:7385

MIOPEN_TYPE_RNG_DISTRIBUTION

@ MIOPEN_TYPE_RNG_DISTRIBUTION

Definition: miopen.h:7184

MIOPEN_TYPE_FLOAT

@ MIOPEN_TYPE_FLOAT

Definition: miopen.h:7159

MIOPEN_TYPE_NUMERICAL_NOTE

@ MIOPEN_TYPE_NUMERICAL_NOTE

Definition: miopen.h:7166

MIOPEN_TYPE_RESAMPLE_MODE

@ MIOPEN_TYPE_RESAMPLE_MODE

Definition: miopen.h:7176

MIOPEN_TYPE_INT32

@ MIOPEN_TYPE_INT32

Definition: miopen.h:7178

MIOPEN_TYPE_POINTWISE_MODE

@ MIOPEN_TYPE_POINTWISE_MODE

Definition: miopen.h:7169

MIOPEN_TYPE_HANDLE

@ MIOPEN_TYPE_HANDLE

Definition: miopen.h:7155

MIOPEN_TYPE_HEUR_MODE

@ MIOPEN_TYPE_HEUR_MODE

Definition: miopen.h:7163

MIOPEN_TYPE_CONVOLUTION_MODE

@ MIOPEN_TYPE_CONVOLUTION_MODE

Definition: miopen.h:7162

MIOPEN_TYPE_TENSOR_REORDERING_MODE

@ MIOPEN_TYPE_TENSOR_REORDERING_MODE

Definition: miopen.h:7175

MIOPEN_TYPE_BOOLEAN

@ MIOPEN_TYPE_BOOLEAN

Definition: miopen.h:7157

MIOPEN_TYPE_NORM_MODE

@ MIOPEN_TYPE_NORM_MODE

Definition: miopen.h:7182

MIOPEN_TYPE_FRACTION

@ MIOPEN_TYPE_FRACTION

Definition: miopen.h:7181

MIOPEN_TYPE_BACKEND_DESCRIPTOR

@ MIOPEN_TYPE_BACKEND_DESCRIPTOR

Definition: miopen.h:7170

MIOPEN_TYPE_ATTRIB_NAME

@ MIOPEN_TYPE_ATTRIB_NAME

Definition: miopen.h:7168

MIOPEN_TYPE_BEHAVIOR_NOTE

@ MIOPEN_TYPE_BEHAVIOR_NOTE

Definition: miopen.h:7174

MIOPEN_TYPE_DATA_TYPE

@ MIOPEN_TYPE_DATA_TYPE

Definition: miopen.h:7156

MIOPEN_TYPE_NAN_PROPOGATION

@ MIOPEN_TYPE_NAN_PROPOGATION

Definition: miopen.h:7165

MIOPEN_TYPE_DOUBLE

@ MIOPEN_TYPE_DOUBLE

Definition: miopen.h:7160

MIOPEN_TYPE_SIGNAL_MODE

@ MIOPEN_TYPE_SIGNAL_MODE

Definition: miopen.h:7180

MIOPEN_TYPE_CHAR

@ MIOPEN_TYPE_CHAR

Definition: miopen.h:7179

MIOPEN_TYPE_PADDING_MODE

@ MIOPEN_TYPE_PADDING_MODE

Definition: miopen.h:7177

MIOPEN_TYPE_INT64

@ MIOPEN_TYPE_INT64

Definition: miopen.h:7158

MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

@ MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE

Definition: miopen.h:7173

MIOPEN_TYPE_LAYOUT_TYPE

@ MIOPEN_TYPE_LAYOUT_TYPE

Definition: miopen.h:7167

MIOPEN_TYPE_GENSTATS_MODE

@ MIOPEN_TYPE_GENSTATS_MODE

Definition: miopen.h:7171

MIOPEN_TYPE_VOID_PTR

@ MIOPEN_TYPE_VOID_PTR

Definition: miopen.h:7161

MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

@ MIOPEN_TYPE_BN_FINALIZE_STATS_MODE

Definition: miopen.h:7172

MIOPEN_TYPE_KNOB_TYPE

@ MIOPEN_TYPE_KNOB_TYPE

Definition: miopen.h:7164

MIOPEN_TYPE_NORM_FWD_PHASE

@ MIOPEN_TYPE_NORM_FWD_PHASE

Definition: miopen.h:7183

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

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

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

miopenRNNMode_t

miopenRNNMode_t

Definition: miopen.h:4162

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

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

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

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

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

miopenGetRNNTempSpaceSizes

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

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

miopenGetRNNPaddingMode

miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t *paddingMode)

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

miopenRNNForward

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

Execute forward training for recurrent layer.

miopenGetRNNDataSeqTensorDescriptor

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

Get shape of RNN seqData tensor.

miopenGetRNNInputTensorSize

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

Obtain the size in bytes of the RNN input tensor.

miopenRNNFWDMode_t

miopenRNNFWDMode_t

Definition: miopen.h:4230

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

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

miopenSetRNNDescriptor_V2

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

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

miopenDestroyRNNDescriptor

miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc)

Destroys the tensor descriptor object.

miopenGetRNNHiddenTensorSize

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

Obtain the size in bytes of the RNN hidden tensor.

miopenSetRNNPaddingMode

miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc, miopenRNNPaddingMode_t paddingMode)

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

miopenRNNForwardInference

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

Execute forward inference for RNN layer.

miopenRNNTANH

@ miopenRNNTANH

Definition: miopen.h:4164

miopenLSTM

@ miopenLSTM

Definition: miopen.h:4165

miopenGRU

@ miopenGRU

Definition: miopen.h:4166

miopenRNNRELU

@ miopenRNNRELU

Definition: miopen.h:4163

miopenRNNlinear

@ miopenRNNlinear

Definition: miopen.h:4174

miopenRNNskip

@ miopenRNNskip

Definition: miopen.h:4175

miopenRNNbidirection

@ miopenRNNbidirection

Definition: miopen.h:4197

miopenRNNunidirection

@ miopenRNNunidirection

Definition: miopen.h:4196

miopenRNNwithBias

@ miopenRNNwithBias

Definition: miopen.h:4206

miopenRNNNoBias

@ miopenRNNNoBias

Definition: miopen.h:4205

miopenRNNDataSeqMajorPadded

@ miopenRNNDataSeqMajorPadded

Definition: miopen.h:4242

miopenRNNDataSeqMajorNotPadded

@ miopenRNNDataSeqMajorNotPadded

Definition: miopen.h:4241

miopenRNNDataBatchMajorPadded

@ miopenRNNDataBatchMajorPadded

Definition: miopen.h:4243

miopenRNNDataUnknownLayout

@ miopenRNNDataUnknownLayout

Definition: miopen.h:4240

miopenRNNroundedDynamic

@ miopenRNNroundedDynamic

Definition: miopen.h:4187

miopenRNNfundamental

@ miopenRNNfundamental

Definition: miopen.h:4185

miopenRNNdefault

@ miopenRNNdefault

Definition: miopen.h:4183

miopenRNNTraining

@ miopenRNNTraining

Definition: miopen.h:4231

miopenRNNInference

@ miopenRNNInference

Definition: miopen.h:4232

miopenRNNAlgoGEMM

@ miopenRNNAlgoGEMM

Definition: miopen.h:4214

miopenRNNIOWithPadding

@ miopenRNNIOWithPadding

Definition: miopen.h:4223

miopenRNNIONotPadded

@ miopenRNNIONotPadded

Definition: miopen.h:4222

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

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.

miopenBatchNormalizationForwardInferenceInvVariance

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

Execute forward inference layer for batch normalization using inverse variance.

miopenBatchNormalizationBackward

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

Execute backwards propagation layer for batch normalization.

miopenBatchNormMode_t

miopenBatchNormMode_t

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

miopenBatchNormForwardInferenceActivationInvVariance

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

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

miopenDeriveBNTensorDescriptor

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

Derive tensor for gamma and beta from input tensor descriptor.

miopenCatForward

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

Execute a cat forward layer.

miopenInitConvolutionNdDescriptor

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

Creates a N-dimensional convolution layer descriptor.

miopenConvolutionForwardImmediate

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

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

miopenConvolutionBackwardDataCompileSolution

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

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

miopenConvolutionForwardGetSolutionWorkspaceSize

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

Returns the workspace size required for a particular solution id.

miopenConvolutionForward

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

Execute a forward convolution layer.

miopenGetConvolutionGroupCount

miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc, int *groupCount)

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

miopenGetConvolutionFindMode

miopenStatus_t miopenGetConvolutionFindMode(const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t *findMode)

Reads the Find Mode attribute from the convolution descriptor.

miopenInitConvolutionDescriptor

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

Creates a 2-D convolution layer descriptor.

miopenConvAlgorithm_t

miopenConvAlgorithm_t

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

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

miopenFindResultsOrder_t

miopenFindResultsOrder_t

Definition: miopen.h:6108

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

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

miopenFindSolutions

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

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

miopenSetFindOptionTuning

miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value)

Sets the tuning find option. Default value is zero.

miopenGetSolutionWorkspaceSize

miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution, size_t *workspaceSize)

Reads the amount of workspace required to execute the solution.

miopenSetFindOptionResultsOrder

miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options, miopenFindResultsOrder_t value)

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

miopenRunSolution

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

Runs the solution using the passed in buffers.

miopenCreateMhaProblem

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

miopenProblemDirection_t

miopenProblemDirection_t

Definition: miopen.h:6014

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

miopenFindResultsOrderByTime

@ miopenFindResultsOrderByTime

Definition: miopen.h:6109

miopenMhaMaskCausal

@ miopenMhaMaskCausal

Definition: miopen.h:6138

miopenMhaMaskNone

@ miopenMhaMaskNone

Definition: miopen.h:6137

miopenTensorMhaDescaleS

@ miopenTensorMhaDescaleS

Definition: miopen.h:6039

miopenTensorMhaO

@ miopenTensorMhaO

Definition: miopen.h:6045

miopenTensorMhaAmaxDV

@ miopenTensorMhaAmaxDV

Definition: miopen.h:6063

miopenTensorBatchnormScaleDiff

@ miopenTensorBatchnormScaleDiff

Definition: miopen.h:6086

miopenTensorMhaMask

@ miopenTensorMhaMask

Definition: miopen.h:6097

miopenTensorMhaDescaleDS

@ miopenTensorMhaDescaleDS

Definition: miopen.h:6053

miopenTensorMhaDropoutSeed

@ miopenTensorMhaDropoutSeed

Definition: miopen.h:6043

miopenTensorBatchnormSavedMean

@ miopenTensorBatchnormSavedMean

Definition: miopen.h:6083

miopenTensorActivationDY

@ miopenTensorActivationDY

Definition: miopen.h:6071

miopenTensorBatchnormDX

@ miopenTensorBatchnormDX

Definition: miopen.h:6091

miopenTensorMhaDescaleV

@ miopenTensorMhaDescaleV

Definition: miopen.h:6038

miopenTensorMhaK

@ miopenTensorMhaK

Definition: miopen.h:6033

miopenTensorConvolutionX

@ miopenTensorConvolutionX

Definition: miopen.h:6029

miopenTensorMhaAmaxDK

@ miopenTensorMhaAmaxDK

Definition: miopen.h:6062

miopenTensorMhaScaleDS

@ miopenTensorMhaScaleDS

Definition: miopen.h:6054

miopenTensorBatchnormBias

@ miopenTensorBatchnormBias

Definition: miopen.h:6089

miopenTensorMhaM

@ miopenTensorMhaM

Definition: miopen.h:6048

miopenTensorBatchnormRunningMean

@ miopenTensorBatchnormRunningMean

Definition: miopen.h:6081

miopenTensorMhaDropoutProbability

@ miopenTensorMhaDropoutProbability

Definition: miopen.h:6042

miopenTensorSoftmaxY

@ miopenTensorSoftmaxY

Definition: miopen.h:6076

miopenTensorSoftmaxDY

@ miopenTensorSoftmaxDY

Definition: miopen.h:6078

miopenTensorMhaDescaleO

@ miopenTensorMhaDescaleO

Definition: miopen.h:6051

miopenTensorMhaScaleO

@ miopenTensorMhaScaleO

Definition: miopen.h:6041

miopenScalarBatchnormExpAvgFactor

@ miopenScalarBatchnormExpAvgFactor

Definition: miopen.h:6099

miopenTensorBatchnormScale

@ miopenTensorBatchnormScale

Definition: miopen.h:6085

miopenTensorBatchnormRunningVariance

@ miopenTensorBatchnormRunningVariance

Definition: miopen.h:6082

miopenTensorActivationDX

@ miopenTensorActivationDX

Definition: miopen.h:6070

miopenTensorMhaScaleDK

@ miopenTensorMhaScaleDK

Definition: miopen.h:6056

miopenTensorMhaV

@ miopenTensorMhaV

Definition: miopen.h:6035

miopenTensorMhaAmaxS

@ miopenTensorMhaAmaxS

Definition: miopen.h:6047

miopenTensorBatchnormBiasDiff

@ miopenTensorBatchnormBiasDiff

Definition: miopen.h:6090

miopenTensorBatchnormSavedVariance

@ miopenTensorBatchnormSavedVariance

Definition: miopen.h:6084

miopenTensorActivationX

@ miopenTensorActivationX

Definition: miopen.h:6068

miopenTensorMhaScaleDV

@ miopenTensorMhaScaleDV

Definition: miopen.h:6057

miopenTensorMhaAmaxO

@ miopenTensorMhaAmaxO

Definition: miopen.h:6046

miopenScalarBatchnormEpsilon

@ miopenScalarBatchnormEpsilon

Definition: miopen.h:6100

miopenTensorMhaScaleDQ

@ miopenTensorMhaScaleDQ

Definition: miopen.h:6055

miopenTensorSoftmaxDX

@ miopenTensorSoftmaxDX

Definition: miopen.h:6077

miopenTensorMhaAmaxDS

@ miopenTensorMhaAmaxDS

Definition: miopen.h:6064

miopenTensorMhaDV

@ miopenTensorMhaDV

Definition: miopen.h:6060

miopenTensorMhaQ

@ miopenTensorMhaQ

Definition: miopen.h:6034

miopenTensorMhaAmaxDQ

@ miopenTensorMhaAmaxDQ

Definition: miopen.h:6061

miopenTensorConvolutionY

@ miopenTensorConvolutionY

Definition: miopen.h:6031

miopenTensorBatchnormEstimatedMean

@ miopenTensorBatchnormEstimatedMean

Definition: miopen.h:6087

miopenTensorBatchnormDY

@ miopenTensorBatchnormDY

Definition: miopen.h:6092

miopenTensorMhaZInv

@ miopenTensorMhaZInv

Definition: miopen.h:6049

miopenTensorMhaDescaleQ

@ miopenTensorMhaDescaleQ

Definition: miopen.h:6037

miopenTensorMhaBias

@ miopenTensorMhaBias

Definition: miopen.h:6065

miopenTensorBatchnormEstimatedVariance

@ miopenTensorBatchnormEstimatedVariance

Definition: miopen.h:6088

miopenTensorArgumentIsScalar

@ miopenTensorArgumentIsScalar

Definition: miopen.h:6095

miopenTensorArgumentIdInvalid

@ miopenTensorArgumentIdInvalid

Definition: miopen.h:6028

miopenTensorMhaDO

@ miopenTensorMhaDO

Definition: miopen.h:6050

miopenTensorMhaDescaleDO

@ miopenTensorMhaDescaleDO

Definition: miopen.h:6052

miopenTensorConvolutionW

@ miopenTensorConvolutionW

Definition: miopen.h:6030

miopenTensorMhaDescaleK

@ miopenTensorMhaDescaleK

Definition: miopen.h:6036

miopenTensorMhaDropoutOffset

@ miopenTensorMhaDropoutOffset

Definition: miopen.h:6044

miopenTensorBiasY

@ miopenTensorBiasY

Definition: miopen.h:6073

miopenTensorMhaDQ

@ miopenTensorMhaDQ

Definition: miopen.h:6058

miopenTensorSoftmaxX

@ miopenTensorSoftmaxX

Definition: miopen.h:6075

miopenTensorBatchnormY

@ miopenTensorBatchnormY

Definition: miopen.h:6080

miopenTensorMhaScaleS

@ miopenTensorMhaScaleS

Definition: miopen.h:6040

miopenTensorBias

@ miopenTensorBias

Definition: miopen.h:6074

miopenTensorActivationY

@ miopenTensorActivationY

Definition: miopen.h:6069

miopenTensorBatchnormX

@ miopenTensorBatchnormX

Definition: miopen.h:6079

miopenTensorBiasX

@ miopenTensorBiasX

Definition: miopen.h:6072

miopenTensorMhaDK

@ miopenTensorMhaDK

Definition: miopen.h:6059

miopenProblemDirectionBackwardWeights

@ miopenProblemDirectionBackwardWeights

Definition: miopen.h:6017

miopenProblemDirectionInference

@ miopenProblemDirectionInference

Definition: miopen.h:6019

miopenProblemDirectionForward

@ miopenProblemDirectionForward

Definition: miopen.h:6015

miopenProblemDirectionBackward

@ miopenProblemDirectionBackward

Definition: miopen.h:6016

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

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

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

MIOPEN_REDUCE_CALCULATION_SUM

@ MIOPEN_REDUCE_CALCULATION_SUM

Definition: miopen.h:6544

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

MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN

Definition: miopen.h:6527

MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

@ MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN

Definition: miopen.h:6526

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

MIOPEN_LOSS_REDUCTION_SUM

@ MIOPEN_LOSS_REDUCTION_SUM

Definition: miopen.h:8444

MIOPEN_LOSS_REDUCTION_NONE

@ MIOPEN_LOSS_REDUCTION_NONE

Definition: miopen.h:8443

miopenTuningPolicyDbClean

@ miopenTuningPolicyDbClean

Definition: miopen.h:8630

miopenTuningPolicyDbUpdate

@ miopenTuningPolicyDbUpdate

Definition: miopen.h:8627

miopenTuningPolicyNone

@ miopenTuningPolicyNone

Definition: miopen.h:8626

miopenTuningPolicySearch

@ miopenTuningPolicySearch

Definition: miopen.h:8628

miopenTuningPolicySearchDbUpdate

@ miopenTuningPolicySearchDbUpdate

Definition: miopen.h:8629

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

MIOPEN_REDUCE_EXTREME_MIN

@ MIOPEN_REDUCE_EXTREME_MIN

Definition: miopen.h:6606

MIOPEN_REDUCE_EXTREME_MAX

@ MIOPEN_REDUCE_EXTREME_MAX

Definition: miopen.h:6608

MIOPEN_REDUCE_EXTREME_ARGMIN

@ MIOPEN_REDUCE_EXTREME_ARGMIN

Definition: miopen.h:6602

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

miopenTensorArgument_t::id

miopenTensorArgumentId_t id

Definition: miopen.h:6342

miopenTensorArgument_t::buffer

void * buffer

Definition: miopen.h:6352

miopenTensorArgument_t::descriptor

miopenTensorDescriptor_t * descriptor

Definition: miopen.h:6348