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

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

MIOpen: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-miopen/checkouts/docs-6.4.3/include/miopen/miopen.h Source File
Go to the documentation of this file.
 /*******************************************************************************
  *
  * MIT License
  *
  * Copyright (c) 2023 Advanced Micro Devices, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
  *******************************************************************************/
 #ifndef MIOPEN_GUARD_MIOPEN_H_
 #define MIOPEN_GUARD_MIOPEN_H_
  
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wextern-c-compat"
 #endif
  
 #include <stddef.h>
 #include <stdbool.h>
 #include <miopen/config.h>
 #include <miopen/export.h>
  
 #if MIOPEN_BACKEND_OPENCL
 #define CL_TARGET_OPENCL_VERSION 120
 #if defined(__APPLE__) || defined(__MACOSX)
 #include <OpenCL/cl.h>
 #else
 #define CL_USE_DEPRECATED_OPENCL_1_2_APIS
 #include <CL/cl.h>
 #endif
  
 #elif MIOPEN_BACKEND_HIP
 #include <hip/hip_runtime_api.h>
 #endif
  
 /*
  * @defgroup convolutions
  * @defgroup pooling
  * @defgroup handle
  * @defgroup layernorm
  * @defgroup LRN
  * @defgroup batchnorm
  * @defgroup activation
  * @defgroup tensor
  * @defgroup softmax
  * @defgroup RNN
  * @defgroup fusion
  * @defgroup LossFunction
  * @defgroup TensorReduce
  * @defgroup find2
  * @defgroup ReduceExtreme
  * @defgroup groupnorm
  * @defgroup cat
  * @defgroup SGD
  * @defgroup getitem
  * @defgroup ReduceCalculation
  * @defgroup RotaryPositionalEmbeddings
  * @defgroup ReLU
  *
  */
  
 #define MIOPEN_DECLARE_OBJECT(name) \
     struct name                     \
     {                               \
     };                              \
     typedef struct name* name##_t;
  
 #ifdef __cplusplus
 extern "C" {
 #endif
  
 #if MIOPEN_BACKEND_OPENCL
 typedef cl_command_queue miopenAcceleratorQueue_t;
 #elif MIOPEN_BACKEND_HIP
 typedef hipStream_t miopenAcceleratorQueue_t;
 #endif
  
 MIOPEN_DECLARE_OBJECT(miopenHandle);
  
 typedef enum
 {
     miopenStatusSuccess              = 0, 
     miopenStatusNotInitialized       = 1, 
     miopenStatusInvalidValue         = 2, 
     miopenStatusBadParm              = 3, 
     miopenStatusAllocFailed          = 4, 
     miopenStatusInternalError        = 5, 
     miopenStatusNotImplemented       = 6, 
     miopenStatusUnknownError         = 7, 
     miopenStatusUnsupportedOp        = 8, 
     miopenStatusGpuOperationsSkipped = 9, 
     miopenStatusVersionMismatch = 10, 
 } miopenStatus_t;
  
 #ifdef MIOPEN_BETA_API
 typedef enum
 {
     miopenF8RoundingModeStandard   = 0,
     miopenF8RoundingModeStochastic = 1,
 } miopenF8RoundingMode_t;
 #endif
  
 MIOPEN_EXPORT const char* miopenGetErrorString(miopenStatus_t error);
  
 typedef void* (*miopenAllocatorFunction)(void* context, size_t sizeBytes);
  
 typedef void (*miopenDeallocatorFunction)(void* context, void* memory);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetVersion(size_t* major, size_t* minor, size_t* patch);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreate(miopenHandle_t* handle);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateWithStream(miopenHandle_t* handle,
                                                     miopenAcceleratorQueue_t stream);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroy(miopenHandle_t handle);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetStream(miopenHandle_t handle,
                                              miopenAcceleratorQueue_t streamID);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetStream(miopenHandle_t handle,
                                              miopenAcceleratorQueue_t* streamID);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetAllocator(miopenHandle_t handle,
                                                 miopenAllocatorFunction allocator,
                                                 miopenDeallocatorFunction deallocator,
                                                 void* allocatorContext);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetKernelTime(miopenHandle_t handle, float* time);
  
 MIOPEN_EXPORT miopenStatus_t miopenEnableProfiling(miopenHandle_t handle, bool enable);
 // CLOSEOUT HANDLE DOXYGEN GROUP
  
 MIOPEN_DECLARE_OBJECT(miopenFusionOpDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenTensorDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenSeqTensorDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenConvolutionDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenPoolingDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenLRNDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenActivationDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenRNNDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenCTCLossDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenDropoutDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenReduceTensorDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenMhaDescriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenSoftmaxDescriptor);
  
 typedef enum
 {
     miopenHalf  = 0, 
     miopenFloat = 1, 
     miopenInt32 = 2, 
     miopenInt8  = 3, 
     // miopenInt8x4   = 4, /*!< Pack of 4x Int8 in NCHW_VECT_C format (Support discontinued) */
     miopenBFloat16 = 5, 
     miopenDouble = 6,   
 #ifdef MIOPEN_BETA_API
     miopenFloat8  = 7,
     miopenBFloat8 = 8,
 #else
 // miopenReserved1 = 7,
 // miopenReserved2 = 8,
 #endif
     miopenInt64 = 9,
 } miopenDataType_t;
  
 typedef enum
 {
     miopenTensorNCHW   = 0, 
     miopenTensorNHWC   = 1, 
     miopenTensorCHWN   = 2, 
     miopenTensorNCHWc4 = 3, 
     miopenTensorNCHWc8 = 4, 
     miopenTensorCHWNc4 = 5, 
     miopenTensorCHWNc8 = 6, 
     miopenTensorNCDHW  = 7, 
     miopenTensorNDHWC  = 8, 
 } miopenTensorLayout_t;
  
 typedef enum
 {
     miopenIndexUint8  = 0, 
     miopenIndexUint16 = 1, 
     miopenIndexUint32 = 2, 
     miopenIndexUint64 = 3, 
 } miopenIndexType_t;
  
 typedef enum
 {
     miopenTensorOpAdd = 0, 
     miopenTensorOpMul = 1, 
     miopenTensorOpMin = 2, 
     miopenTensorOpMax = 3, 
 } miopenTensorOp_t;
  
 typedef enum
 {
     miopenConvolution = 0, 
     miopenTranspose   = 1, 
     miopenGroupConv   = 2, 
     miopenDepthwise   = 3, 
 } miopenConvolutionMode_t;
  
 typedef enum
 {
     miopenPaddingDefault = 0, 
     miopenPaddingSame    = 1, 
     miopenPaddingValid   = 2, 
 } miopenPaddingMode_t;
  
 typedef enum
 {
     miopenPoolingMax              = 0, 
     miopenPoolingAverage          = 1, 
     miopenPoolingAverageInclusive = 2, 
 } miopenPoolingMode_t;
  
 typedef enum
 {
     miopenPoolingWorkspaceIndexMask  = 0, 
     miopenPoolingWorkspaceIndexImage = 1, 
 } miopenPoolingWorkspaceIndexMode_t;
  
 typedef enum
 {
     miopenLRNWithinChannel = 0, 
     miopenLRNCrossChannel  = 1, 
 } miopenLRNMode_t;
 #ifdef MIOPEN_BETA_API
 typedef enum
 {
     MIOPEN_ELEMENTWISE_AFFINE = 0, 
     MIOPEN_WEIGHT_BIAS =
         1, 
     MIOPEN_ELEMENTWISE_AFFINE_FUSED_ADD =
         2, 
     MIOPEN_WEIGHT_BIAS_FUSED_ADD = 3, 
     MIOPEN_ELEMENTWISE_AFFINE_T5 =
         4, 
     MIOPEN_WEIGHT_BIAS_T5 = 5, 
 } miopenNormMode_t;
 #endif
 typedef enum
 {
     miopenBNPerActivation = 0, 
     miopenBNSpatial       = 1, 
 } miopenBatchNormMode_t;
  
 typedef enum
 {
     miopenActivationPASTHRU  = 0, 
     miopenActivationLOGISTIC = 1, 
     miopenActivationTANH     = 2, 
     miopenActivationRELU     = 3, 
     miopenActivationSOFTRELU = 4, 
     miopenActivationABS      = 5, 
     miopenActivationPOWER = 6, 
     miopenActivationCLIPPEDRELU =
         7, 
     miopenActivationLEAKYRELU =
         8, 
     miopenActivationELU =
         9, 
 } miopenActivationMode_t;
  
 typedef enum
 {
     MIOPEN_SOFTMAX_FAST     = 0, 
     MIOPEN_SOFTMAX_ACCURATE = 1, 
     MIOPEN_SOFTMAX_LOG      = 2, 
 } miopenSoftmaxAlgorithm_t;
  
 typedef enum
 {
     MIOPEN_SOFTMAX_MODE_INSTANCE = 0, 
     MIOPEN_SOFTMAX_MODE_CHANNEL =
         1, 
 } miopenSoftmaxMode_t;
  
 #define MIOPEN_API_VERSION_REDUCE_TENSOR 1
  
 typedef enum
 {
     MIOPEN_REDUCE_TENSOR_ADD = 0, 
     MIOPEN_REDUCE_TENSOR_MUL =
         1, 
     MIOPEN_REDUCE_TENSOR_MIN =
         2, 
     MIOPEN_REDUCE_TENSOR_MAX =
         3, 
     MIOPEN_REDUCE_TENSOR_AMAX =
         4, 
     MIOPEN_REDUCE_TENSOR_AVG =
         5, 
     MIOPEN_REDUCE_TENSOR_NORM1 =
         6, 
     MIOPEN_REDUCE_TENSOR_NORM2 = 7, 
     // MIOPEN_REDUCE_TENSOR_MUL_NO_ZEROS =
     //    8, /*!< the operation is same as MUL, but does not have the zero values considered */
 } miopenReduceTensorOp_t;
  
 typedef enum
 {
     MIOPEN_NOT_PROPAGATE_NAN = 0, 
     MIOPEN_PROPAGATE_NAN     = 1, 
 } miopenNanPropagation_t;
  
 typedef enum
 {
     MIOPEN_REDUCE_TENSOR_NO_INDICES        = 0, 
     MIOPEN_REDUCE_TENSOR_FLATTENED_INDICES = 1, 
 } miopenReduceTensorIndices_t;
  
 typedef enum
 {
     MIOPEN_32BIT_INDICES = 0, 
     MIOPEN_64BIT_INDICES = 1, 
     MIOPEN_16BIT_INDICES = 2, 
     MIOPEN_8BIT_INDICES  = 3, 
 } miopenIndicesType_t;
  
 typedef enum
 {
     MIOPEN_CONVOLUTION_ATTRIB_FP16_ALT_IMPL =
         0, 
     MIOPEN_CONVOLUTION_ATTRIB_DETERMINISTIC =
         1, 
 #ifdef MIOPEN_BETA_API
     MIOPEN_CONVOLUTION_ATTRIB_FP8_ROUNDING_MODE =
         2, 
 #else
 // miopenReserved1 = 2,
 #endif
 } miopenConvolutionAttrib_t;
  
 typedef enum
 {
     miopenConvolutionFindModeNormal =
         1, 
     miopenConvolutionFindModeFast =
         2, 
     miopenConvolutionFindModeHybrid =
         3, 
     // miopenConvolutionFindModeReserved_4 = 4, /*!< Reserved - do not use */
     miopenConvolutionFindModeDynamicHybrid =
         5, 
     miopenConvolutionFindModeDefault =
         miopenConvolutionFindModeDynamicHybrid 
 } miopenConvolutionFindMode_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateTensorDescriptor(miopenTensorDescriptor_t* tensorDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSet4dTensorDescriptor(
     miopenTensorDescriptor_t tensorDesc, miopenDataType_t dataType, int n, int c, int h, int w);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetNdTensorDescriptorWithLayout(miopenTensorDescriptor_t tensorDesc,
                                       miopenDataType_t dataType,
                                       miopenTensorLayout_t tensorLayout,
                                       const int* lens,
                                       int num_lens);
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
                                                        miopenDataType_t dataType,
                                                        int nbDims,
                                                        const int* dimsA,
                                                        const int* stridesA);
  
 #ifdef MIOPEN_BETA_API
 MIOPEN_EXPORT miopenStatus_t miopenSetTensorDescriptorV2(miopenTensorDescriptor_t tensorDesc,
                                                          miopenDataType_t dataType,
                                                          int nbDims,
                                                          const size_t* dimsA,
                                                          const size_t* stridesA);
 #endif
  
 #ifdef MIOPEN_BETA_API
 MIOPEN_EXPORT miopenStatus_t miopenSetTensorCastType(miopenTensorDescriptor_t tensorDesc,
                                                      miopenDataType_t cast_type);
 #endif
  
 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptorSize(miopenTensorDescriptor_t tensorDesc,
                                                            int* size);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetTensorDescriptor(miopenTensorDescriptor_t tensorDesc,
                                                        miopenDataType_t* dataType,
                                                        int* dimsA,
                                                        int* stridesA);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyTensorDescriptor(miopenTensorDescriptor_t tensorDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateSeqTensorDescriptor(miopenSeqTensorDescriptor_t* tensorDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenDestroySeqTensorDescriptor(miopenSeqTensorDescriptor_t tensorDesc);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetTensor(miopenHandle_t handle,
                                              const miopenTensorDescriptor_t yDesc,
                                              void* y,
                                              const void* alpha);
  
 MIOPEN_EXPORT miopenStatus_t miopenScaleTensor(miopenHandle_t handle,
                                                const miopenTensorDescriptor_t yDesc,
                                                void* y,
                                                const void* alpha);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetTensorNumBytes(miopenTensorDescriptor_t tensorDesc,
                                                      size_t* numBytes);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT TENSOR DOXYGEN GROUP
  
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateConvolutionDescriptor(miopenConvolutionDescriptor_t* convDesc);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenInitConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
                                   int spatialDim,
                                   const int* padA,
                                   const int* strideA,
                                   const int* dilationA,
                                   miopenConvolutionMode_t c_mode);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
                                                             int* spatialDim);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetConvolutionNdDescriptor(miopenConvolutionDescriptor_t convDesc,
                                  int requestedSpatialDim,
                                  int* spatialDim,
                                  int* padA,
                                  int* strideA,
                                  int* dilationA,
                                  miopenConvolutionMode_t* c_mode);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
                                                             int* groupCount);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
                                                             int groupCount);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetTransposeConvOutputPadding(miopenConvolutionDescriptor_t convDesc, int adj_h, int adj_w);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetTransposeConvNdOutputPadding(
     miopenConvolutionDescriptor_t convDesc, int spatialDim, const int* adjA);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
                                      const miopenTensorDescriptor_t inputTensorDesc,
                                      const miopenTensorDescriptor_t filterDesc,
                                      int* n,
                                      int* c,
                                      int* h,
                                      int* w);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
                                        const miopenTensorDescriptor_t inputTensorDesc,
                                        const miopenTensorDescriptor_t filterDesc,
                                        int* nDim,
                                        int* outputTensorDimA);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenDestroyConvolutionDescriptor(miopenConvolutionDescriptor_t convDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
                                                            const miopenConvolutionAttrib_t attr,
                                                            int value);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescriptor_t convDesc,
                                                            const miopenConvolutionAttrib_t attr,
                                                            int* value);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetConvolutionFindMode(miopenConvolutionDescriptor_t convDesc,
                                                           miopenConvolutionFindMode_t findMode);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetConvolutionFindMode(
     const miopenConvolutionDescriptor_t convDesc, miopenConvolutionFindMode_t* findMode);
  
 typedef enum
 {
     miopenConvolutionFwdAlgoGEMM         = 0, 
     miopenConvolutionFwdAlgoDirect       = 1, 
     miopenConvolutionFwdAlgoFFT          = 2, 
     miopenConvolutionFwdAlgoWinograd     = 3, 
     miopenConvolutionFwdAlgoImplicitGEMM = 5, 
 } miopenConvFwdAlgorithm_t;
  
 typedef enum
 {
     miopenConvolutionBwdWeightsAlgoGEMM         = 0, 
     miopenConvolutionBwdWeightsAlgoDirect       = 1, 
     miopenConvolutionBwdWeightsAlgoWinograd     = 3, 
     miopenConvolutionBwdWeightsAlgoImplicitGEMM = 5, 
 } miopenConvBwdWeightsAlgorithm_t;
  
 typedef enum
 {
     miopenConvolutionBwdDataAlgoGEMM     = 0, 
     miopenConvolutionBwdDataAlgoDirect   = 1, 
     miopenConvolutionBwdDataAlgoFFT      = 2, 
     miopenConvolutionBwdDataAlgoWinograd = 3, 
     miopenTransposeBwdDataAlgoGEMM =
         4, 
     miopenConvolutionBwdDataAlgoImplicitGEMM = 5, 
 } miopenConvBwdDataAlgorithm_t;
  
 typedef enum
 {
     miopenConvolutionAlgoGEMM         = 0, 
     miopenConvolutionAlgoDirect       = 1, 
     miopenConvolutionAlgoFFT          = 2, 
     miopenConvolutionAlgoWinograd     = 3, 
     miopenConvolutionAlgoImplicitGEMM = 5, 
 } miopenConvAlgorithm_t;
  
 typedef struct
 {
     union
     {
         miopenConvFwdAlgorithm_t fwd_algo; 
         miopenConvBwdWeightsAlgorithm_t bwd_weights_algo; 
         miopenConvBwdDataAlgorithm_t
             bwd_data_algo; 
     };
  
     float time;    
     size_t memory; 
 } miopenConvAlgoPerf_t;
  
 typedef struct
 {
     float time; 
     size_t workspace_size; 
     uint64_t solution_id;  
     miopenConvAlgorithm_t algorithm; 
 } miopenConvSolution_t;
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT CONVOLUTIONS DOXYGEN GROUP
  
 // Pooling APIs
 MIOPEN_EXPORT miopenStatus_t miopenCreatePoolingDescriptor(miopenPoolingDescriptor_t* poolDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
                                                        miopenIndexType_t index_type);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingIndexType(miopenPoolingDescriptor_t poolDesc,
                                                        miopenIndexType_t* index_type);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetPoolingWorkSpaceIndexMode(
     miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t workspace_index);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetPoolingWorkSpaceIndexMode(
     miopenPoolingDescriptor_t poolDesc, miopenPoolingWorkspaceIndexMode_t* workspace_index);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetPoolingForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
                                  const miopenTensorDescriptor_t tensorDesc,
                                  int* n,
                                  int* c,
                                  int* h,
                                  int* w);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetNdPoolingDescriptor(miopenPoolingDescriptor_t poolDesc,
                                                           const miopenPoolingMode_t mode,
                                                           int nbDims,
                                                           const int* windowDimA,
                                                           const int* padA,
                                                           const int* stridesA);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetNdPoolingDescriptor(const miopenPoolingDescriptor_t poolDesc,
                                                           int nbDimsRequested,
                                                           miopenPoolingMode_t* mode,
                                                           int* nbDims,
                                                           int* windowDimA,
                                                           int* padA,
                                                           int* stridesA);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetPoolingNdForwardOutputDim(const miopenPoolingDescriptor_t poolDesc,
                                    const miopenTensorDescriptor_t tensorDesc,
                                    int dims,
                                    int* tensorDimArr);
  
 MIOPEN_EXPORT miopenStatus_t miopenPoolingGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
                                                            size_t* workSpaceSize);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenPoolingGetWorkSpaceSizeV2(const miopenPoolingDescriptor_t poolDesc,
                                 const miopenTensorDescriptor_t yDesc,
                                 size_t* workSpaceSize);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyPoolingDescriptor(miopenPoolingDescriptor_t poolDesc);
  
 // CLOSEOUT POOLING DOXYGEN GROUP
  
 // LRN APIs
 MIOPEN_EXPORT miopenStatus_t miopenCreateLRNDescriptor(miopenLRNDescriptor_t* lrnDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
                                                     miopenLRNMode_t mode,
                                                     unsigned int lrnN,
                                                     double lrnAlpha,
                                                     double lrnBeta,
                                                     double lrnK);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrnDesc,
                                                     miopenLRNMode_t* mode,
                                                     unsigned int* lrnN,
                                                     double* lrnAlpha,
                                                     double* lrnBeta,
                                                     double* lrnK);
  
 MIOPEN_EXPORT miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
                                                        size_t* workSpaceSize);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyLRNDescriptor(miopenLRNDescriptor_t lrnDesc);
  
 // CLOSEOUT LRN DOXYGEN GROUP
  
 #ifdef MIOPEN_BETA_API
 // LayerNorm APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT LAYERNORM DOXYGEN GROUP
 #endif
  
 #ifdef MIOPEN_BETA_API
 // Cat APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT CAT DOXYGEN GROUP
 #endif
  
 // Batch-Normalization APIs
 MIOPEN_EXPORT miopenStatus_t miopenDeriveBNTensorDescriptor(miopenTensorDescriptor_t derivedBnDesc,
                                                             const miopenTensorDescriptor_t xDesc,
                                                             miopenBatchNormMode_t bn_mode);
  
 MIOPEN_EXPORT 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);
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT BATCHNORM DOXYGEN GROUP
  
 // Activation APIs
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateActivationDescriptor(miopenActivationDescriptor_t* activDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
                               miopenActivationMode_t mode,
                               double activAlpha,
                               double activBeta,
                               double activGamma);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetActivationDescriptor(const miopenActivationDescriptor_t activDesc,
                               miopenActivationMode_t* mode,
                               double* activAlpha,
                               double* activBeta,
                               double* activGamma);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenDestroyActivationDescriptor(miopenActivationDescriptor_t activDesc);
  
 // CLOSEOUT ACTIVATION DOXYGEN GROUP
  
 #ifdef MIOPEN_BETA_API
 MIOPEN_EXPORT miopenStatus_t miopenGLUForward(miopenHandle_t handle,
                                               const miopenTensorDescriptor_t inputDesc,
                                               const void* input,
                                               const miopenTensorDescriptor_t outputDesc,
                                               void* output,
                                               const uint32_t dim);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT ACTIVATION DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 // Softmax APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT SOFTMAX DOXYGEN GROUP
  
 MIOPEN_DECLARE_OBJECT(miopenFusionPlanDescriptor);
 MIOPEN_DECLARE_OBJECT(miopenOperatorDescriptor);
 MIOPEN_DECLARE_OBJECT(miopenOperatorArgs);
  
 typedef enum
 {
     miopenVerticalFusion   = 0, 
     miopenHorizontalFusion = 1, 
 } miopenFusionDirection_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateFusionPlan(miopenFusionPlanDescriptor_t* fusePlanDesc,
                                                     const miopenFusionDirection_t fuseDirection,
                                                     const miopenTensorDescriptor_t inputDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyFusionPlan(miopenFusionPlanDescriptor_t fusePlanDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenCompileFusionPlan(miopenHandle_t handle,
                                                      miopenFusionPlanDescriptor_t fusePlanDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanGetOp(miopenFusionPlanDescriptor_t fusePlanDesc,
                                                    const int op_idx,
                                                    miopenFusionOpDescriptor_t* op);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
                                  miopenFusionPlanDescriptor_t fusePlanDesc,
                                  size_t* workSpaceSize,
                                  miopenConvFwdAlgorithm_t algo);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
                                    const int requestAlgoCount,
                                    int* returnedAlgoCount,
                                    miopenConvFwdAlgorithm_t* returnedAlgos);
  
 MIOPEN_EXPORT miopenStatus_t miopenFusionPlanConvolutionSetAlgo(
     miopenFusionPlanDescriptor_t fusePlanDesc, miopenConvFwdAlgorithm_t algo);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateOpConvForward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                                        miopenFusionOpDescriptor_t* convOp,
                                                        miopenConvolutionDescriptor_t convDesc,
                                                        const miopenTensorDescriptor_t wDesc);
  
 //---
  
 // Activation forward create ops ---
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateOpActivationForward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                 miopenFusionOpDescriptor_t* activFwdOp,
                                 miopenActivationMode_t mode);
  
 // Activation backward create ops ---
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateOpActivationBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                  miopenFusionOpDescriptor_t* activBwdOp,
                                  miopenActivationMode_t mode);
  
 // Bias create ops ---
 MIOPEN_EXPORT miopenStatus_t miopenCreateOpBiasForward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                                        miopenFusionOpDescriptor_t* biasOp,
                                                        const miopenTensorDescriptor_t bDesc);
  
 // Batch normalization create ops ---
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateOpBatchNormInference(miopenFusionPlanDescriptor_t fusePlanDesc,
                                  miopenFusionOpDescriptor_t* bnOp,
                                  const miopenBatchNormMode_t bn_mode,
                                  const miopenTensorDescriptor_t bnScaleBiasMeanVarDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateOpBatchNormForward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                miopenFusionOpDescriptor_t* bnFwdOp,
                                const miopenBatchNormMode_t bn_mode,
                                bool runningMeanVariance);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateOpBatchNormBackward(miopenFusionPlanDescriptor_t fusePlanDesc,
                                 miopenFusionOpDescriptor_t* bnBwdOp,
                                 const miopenBatchNormMode_t bn_mode);
  
 //---
 MIOPEN_EXPORT miopenStatus_t miopenCreateOperatorArgs(miopenOperatorArgs_t* args);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyOperatorArgs(miopenOperatorArgs_t args);
  
 // Convolution set arguments ---
 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsConvForward(miopenOperatorArgs_t args,
                                                         const miopenFusionOpDescriptor_t convOp,
                                                         const void* alpha,
                                                         const void* beta,
                                                         const void* w);
 // Activation set arguments ---
 MIOPEN_EXPORT miopenStatus_t
 miopenSetOpArgsActivForward(miopenOperatorArgs_t args,
                             const miopenFusionOpDescriptor_t activFwdOp,
                             const void* alpha,
                             const void* beta,
                             double activAlpha,
                             double activBeta,
                             double activGamma);
  
 MIOPEN_EXPORT 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);
  
 // Batch Normalization set arguments ---
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // Bias forward set arguments ---
 MIOPEN_EXPORT miopenStatus_t miopenSetOpArgsBiasForward(miopenOperatorArgs_t args,
                                                         const miopenFusionOpDescriptor_t biasOp,
                                                         const void* alpha,
                                                         const void* beta,
                                                         const void* bias);
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
 // CLOSEOUT FUSION DOXYGEN GROUP
  
 typedef enum
 {
     miopenRNNRELU = 0, 
     miopenRNNTANH = 1, 
     miopenLSTM    = 2, 
     miopenGRU     = 3, 
 } miopenRNNMode_t;
  
 typedef enum
 {
     miopenRNNlinear = 0, 
     miopenRNNskip   = 1, 
 } miopenRNNInputMode_t;
  
 typedef enum
 {
     miopenRNNdefault = 0,        
     miopenRNNfundamental = 1,    
     miopenRNNroundedDynamic = 2, 
 } miopenRNNAlgo_t;
  
 typedef enum
 {
     miopenRNNunidirection = 0, 
     miopenRNNbidirection  = 1, 
 } miopenRNNDirectionMode_t;
  
 typedef enum
 {
     miopenRNNNoBias   = 0, 
     miopenRNNwithBias = 1, 
 } miopenRNNBiasMode_t;
  
 typedef enum
 {
     miopenRNNAlgoGEMM = 0,
 } miopenRNNGEMMalgoMode_t;
  
 typedef enum
 {
     miopenRNNIONotPadded   = 0, 
     miopenRNNIOWithPadding = 1, 
 } miopenRNNPaddingMode_t;
  
 typedef enum
 {
     miopenRNNTraining  = 0, 
     miopenRNNInference = 1, 
 } miopenRNNFWDMode_t;
  
 typedef enum
 {
     miopenRNNDataUnknownLayout     = 0,
     miopenRNNDataSeqMajorNotPadded = 1,
     miopenRNNDataSeqMajorPadded    = 2,
     miopenRNNDataBatchMajorPadded  = 3,
 } miopenRNNBaseLayout_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateRNNDescriptor(miopenRNNDescriptor_t* rnnDesc);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyRNNDescriptor(miopenRNNDescriptor_t rnnDesc);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
                                     miopenDataType_t dataType,
                                     miopenRNNBaseLayout_t layout,
                                     int maxSequenceLen,
                                     int batchSize,
                                     int vectorSize,
                                     const int* sequenceLenArray,
                                     void* paddingMarker);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetRNNDataSeqTensorDescriptor(miopenSeqTensorDescriptor_t seqTensorDesc,
                                     miopenDataType_t* dataType,
                                     miopenRNNBaseLayout_t* layout,
                                     int* maxSequenceLen,
                                     int* batchSize,
                                     int* vectorSize,
                                     int sequenceLenArrayLimit,
                                     int* sequenceLenArray,
                                     void* paddingMarker);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNWorkspaceSize(miopenHandle_t handle,
                                                        const miopenRNNDescriptor_t rnnDesc,
                                                        const int sequenceLen,
                                                        const miopenTensorDescriptor_t* xDesc,
                                                        size_t* numBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTrainingReserveSize(miopenHandle_t handle,
                                                              miopenRNNDescriptor_t rnnDesc,
                                                              const int sequenceLen,
                                                              const miopenTensorDescriptor_t* xDesc,
                                                              size_t* numBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNTempSpaceSizes(miopenHandle_t handle,
                                                         miopenRNNDescriptor_t rnnDesc,
                                                         miopenSeqTensorDescriptor_t xDesc,
                                                         miopenRNNFWDMode_t fwdMode,
                                                         size_t* workSpaceSize,
                                                         size_t* reserveSpaceSize);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsSize(miopenHandle_t handle,
                                                     miopenRNNDescriptor_t rnnDesc,
                                                     miopenTensorDescriptor_t xDesc,
                                                     size_t* numBytes,
                                                     miopenDataType_t dtype);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNParamsDescriptor(miopenHandle_t handle,
                                                           miopenRNNDescriptor_t rnnDesc,
                                                           miopenTensorDescriptor_t xDesc,
                                                           miopenTensorDescriptor_t wDesc,
                                                           miopenDataType_t dtype);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNInputTensorSize(miopenHandle_t handle,
                                                          miopenRNNDescriptor_t rnnDesc,
                                                          const int seqLen,
                                                          miopenTensorDescriptor_t* xDesc,
                                                          size_t* numBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNHiddenTensorSize(miopenHandle_t handle,
                                                           miopenRNNDescriptor_t rnnDesc,
                                                           const int seqLen,
                                                           miopenTensorDescriptor_t* xDesc,
                                                           size_t* numBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamSize(miopenHandle_t handle,
                                                         miopenRNNDescriptor_t rnnDesc,
                                                         const int layer,
                                                         miopenTensorDescriptor_t xDesc,
                                                         const int paramID,
                                                         size_t* numBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasSize(miopenHandle_t handle,
                                                        miopenRNNDescriptor_t rnnDesc,
                                                        const int layer,
                                                        const int biasID,
                                                        size_t* numBytes);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerParamOffset(miopenRNNDescriptor_t rnnDesc,
                                                           const int layer,
                                                           miopenTensorDescriptor_t xDesc,
                                                           const int paramID,
                                                           miopenTensorDescriptor_t paramDesc,
                                                           size_t* layerParamOffset);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNLayerBiasOffset(miopenRNNDescriptor_t rnnDesc,
                                                          const int layer,
                                                          miopenTensorDescriptor_t xDesc,
                                                          const int biasID,
                                                          miopenTensorDescriptor_t biasDesc,
                                                          size_t* layerBiasOffset);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
                                                      miopenRNNPaddingMode_t paddingMode);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetRNNPaddingMode(miopenRNNDescriptor_t rnnDesc,
                                                      miopenRNNPaddingMode_t* paddingMode);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT RNN DOXYGEN GROUP
  
 typedef enum
 {
     MIOPEN_CTC_LOSS_ALGO_DETERMINISTIC = 0, 
 } miopenCTCLossAlgo_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateCTCLossDescriptor(miopenCTCLossDescriptor_t* ctcLossDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
                                                         miopenDataType_t* dataType,
                                                         int* blank_label_id,
                                                         bool* apply_softmax_layer);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetCTCLossDescriptor(miopenCTCLossDescriptor_t ctcLossDesc,
                                                         miopenDataType_t dataType,
                                                         const int blank_label_id,
                                                         bool apply_softmax_layer);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT LossFunction DOXYGEN GROUP
  
 // Dropout APIs
 typedef enum
 {
     MIOPEN_RNG_PSEUDO_XORWOW = 0, 
 } miopenRNGType_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_t* dropoutDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
                                                               size_t* reserveSpaceSizeInBytes);
  
 MIOPEN_EXPORT miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
                                                         size_t* stateSizeInBytes);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT DROPOUT DOXYGEN GROUP
  
 // TensorReduce APIs
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateReduceTensorDescriptor(miopenReduceTensorDescriptor_t* reduceTensorDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenDestroyReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetReduceTensorDescriptor(miopenReduceTensorDescriptor_t reduceTensorDesc,
                                 miopenReduceTensorOp_t reduceTensorOp,
                                 miopenDataType_t reduceTensorCompType,
                                 miopenNanPropagation_t reduceTensorNanOpt,
                                 miopenReduceTensorIndices_t reduceTensorIndices,
                                 miopenIndicesType_t reduceTensorIndicesType);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetReduceTensorDescriptor(const miopenReduceTensorDescriptor_t reduceTensorDesc,
                                 miopenReduceTensorOp_t* reduceTensorOp,
                                 miopenDataType_t* reduceTensorCompType,
                                 miopenNanPropagation_t* reduceTensorNanOpt,
                                 miopenReduceTensorIndices_t* reduceTensorIndices,
                                 miopenIndicesType_t* reduceTensorIndicesType);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetReductionIndicesSize(miopenHandle_t handle,
                               const miopenReduceTensorDescriptor_t reduceTensorDesc,
                               const miopenTensorDescriptor_t aDesc,
                               const miopenTensorDescriptor_t cDesc,
                               size_t* sizeInBytes);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenGetReductionWorkspaceSize(miopenHandle_t handle,
                                 const miopenReduceTensorDescriptor_t reduceTensorDesc,
                                 const miopenTensorDescriptor_t aDesc,
                                 const miopenTensorDescriptor_t cDesc,
                                 size_t* sizeInBytes);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT TensorReduce DOXYGEN GROUP
  
 // Find 2.0 API
 MIOPEN_DECLARE_OBJECT(miopenProblem);
  
 typedef enum
 {
     miopenProblemDirectionForward         = 0,
     miopenProblemDirectionBackward        = 1,
     miopenProblemDirectionBackwardWeights = 2,
 #ifdef MIOPEN_BETA_API
     miopenProblemDirectionInference = 4,
 #endif
 } miopenProblemDirection_t;
  
 typedef enum
 {
     miopenTensorArgumentIdInvalid = 0,
     miopenTensorConvolutionX      = 1,
     miopenTensorConvolutionW      = 2,
     miopenTensorConvolutionY      = 3,
  
     miopenTensorMhaK                  = 4,
     miopenTensorMhaQ                  = 5,
     miopenTensorMhaV                  = 6,
     miopenTensorMhaDescaleK           = 7,
     miopenTensorMhaDescaleQ           = 8,
     miopenTensorMhaDescaleV           = 9,
     miopenTensorMhaDescaleS           = 10,
     miopenTensorMhaScaleS             = 11,
     miopenTensorMhaScaleO             = 12,
     miopenTensorMhaDropoutProbability = 13,
     miopenTensorMhaDropoutSeed        = 14,
     miopenTensorMhaDropoutOffset      = 15,
     miopenTensorMhaO                  = 16,
     miopenTensorMhaAmaxO              = 17,
     miopenTensorMhaAmaxS              = 18,
     miopenTensorMhaM                  = 19,
     miopenTensorMhaZInv               = 20,
     miopenTensorMhaDO                 = 21,
     miopenTensorMhaDescaleO           = 22,
     miopenTensorMhaDescaleDO          = 23,
     miopenTensorMhaDescaleDS          = 24,
     miopenTensorMhaScaleDS            = 25,
     miopenTensorMhaScaleDQ            = 26,
     miopenTensorMhaScaleDK            = 27,
     miopenTensorMhaScaleDV            = 28,
     miopenTensorMhaDQ                 = 29,
     miopenTensorMhaDK                 = 30,
     miopenTensorMhaDV                 = 31,
     miopenTensorMhaAmaxDQ             = 32,
     miopenTensorMhaAmaxDK             = 33,
     miopenTensorMhaAmaxDV             = 34,
     miopenTensorMhaAmaxDS             = 35,
     miopenTensorMhaBias               = 36,
  
 #ifdef MIOPEN_BETA_API
     miopenTensorActivationX                = 37,
     miopenTensorActivationY                = 38,
     miopenTensorActivationDX               = 39,
     miopenTensorActivationDY               = 40,
     miopenTensorBiasX                      = 41,
     miopenTensorBiasY                      = 42,
     miopenTensorBias                       = 43,
     miopenTensorSoftmaxX                   = 44,
     miopenTensorSoftmaxY                   = 45,
     miopenTensorSoftmaxDX                  = 46,
     miopenTensorSoftmaxDY                  = 47,
     miopenTensorBatchnormX                 = 48,
     miopenTensorBatchnormY                 = 49,
     miopenTensorBatchnormRunningMean       = 50,
     miopenTensorBatchnormRunningVariance   = 51,
     miopenTensorBatchnormSavedMean         = 52,
     miopenTensorBatchnormSavedVariance     = 53,
     miopenTensorBatchnormScale             = 54,
     miopenTensorBatchnormScaleDiff         = 55,
     miopenTensorBatchnormEstimatedMean     = 56,
     miopenTensorBatchnormEstimatedVariance = 57,
     miopenTensorBatchnormBias              = 58,
     miopenTensorBatchnormBiasDiff          = 59,
     miopenTensorBatchnormDX                = 60,
     miopenTensorBatchnormDY                = 61,
 #endif
  
     miopenTensorArgumentIsScalar = 1U << 31,
  
     miopenTensorMhaMask = miopenTensorArgumentIsScalar | 1,
 #ifdef MIOPEN_BETA_API
     miopenScalarBatchnormExpAvgFactor = miopenTensorArgumentIsScalar | 2,
     miopenScalarBatchnormEpsilon      = miopenTensorArgumentIsScalar | 3,
 #endif
 } miopenTensorArgumentId_t;
  
 typedef enum
 {
     miopenFindResultsOrderByTime          = 0,
     miopenFindResultsOrderByWorkspaceSize = 1,
 } miopenFindResultsOrder_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateConvProblem(miopenProblem_t* problem,
                                                      miopenConvolutionDescriptor_t operatorDesc,
                                                      miopenProblemDirection_t direction);
  
 typedef enum
 {
     miopenMhaMaskNone   = 0,
     miopenMhaMaskCausal = 1,
 } miopenMhaMask_t;
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaProblem(miopenProblem_t* problem,
                                                     miopenMhaDescriptor_t operatorDesc,
                                                     miopenProblemDirection_t direction);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateMhaDescriptor(miopenMhaDescriptor_t* mhaDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float scale);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetMhaDescriptor(miopenMhaDescriptor_t mhaDesc, float* scale);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxDescriptor(miopenSoftmaxDescriptor_t* softmaxDesc);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetSoftmaxDescriptor(miopenSoftmaxDescriptor_t softmaxDesc,
                                                         float alpha,
                                                         float beta,
                                                         miopenSoftmaxAlgorithm_t algorithm,
                                                         miopenSoftmaxMode_t mode);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSoftmaxDescriptor(const miopenSoftmaxDescriptor_t softmaxDesc,
                                                         float* alpha,
                                                         float* beta,
                                                         miopenSoftmaxAlgorithm_t* algorithm,
                                                         miopenSoftmaxMode_t* mode);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyProblem(miopenProblem_t problem);
  
 MIOPEN_EXPORT miopenStatus_t
 miopenSetProblemTensorDescriptor(miopenProblem_t problem,
                                  miopenTensorArgumentId_t id,
                                  const miopenTensorDescriptor_t descriptor);
  
 MIOPEN_DECLARE_OBJECT(miopenFindOptions);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateFindOptions(miopenFindOptions_t* options);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroyFindOptions(miopenFindOptions_t options);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionTuning(miopenFindOptions_t options, int value);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionResultsOrder(miopenFindOptions_t options,
                                                              miopenFindResultsOrder_t value);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionWorkspaceLimit(miopenFindOptions_t options,
                                                                size_t value);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedWorkspace(miopenFindOptions_t options,
                                                                       void* buffer,
                                                                       size_t size);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionPreallocatedTensor(miopenFindOptions_t options,
                                                                    miopenTensorArgumentId_t id,
                                                                    void* buffer);
  
 MIOPEN_EXPORT miopenStatus_t miopenSetFindOptionAttachBinaries(miopenFindOptions_t options,
                                                                unsigned attach);
  
 MIOPEN_DECLARE_OBJECT(miopenSolution);
  
 MIOPEN_EXPORT miopenStatus_t miopenFindSolutions(miopenHandle_t handle,
                                                  miopenProblem_t problem,
                                                  miopenFindOptions_t options,
                                                  miopenSolution_t* solutions,
                                                  size_t* numSolutions,
                                                  size_t maxSolutions);
  
 struct miopenTensorArgument_t
 {
     /* @brief Identifier of the tensor argument.
      */
     miopenTensorArgumentId_t id;
     /* @brief Tensor descriptor to override the value stored in the solution.
      *
      * Some solvers may support overriding input and output tensor descriptors, but right now there
      * is no way to tell from the API. Intended for the future use.
      */
     miopenTensorDescriptor_t* descriptor;
     /* @brief Pointer to the device memory buffer to use for the operation or to the host memory if
      * the value is scalar.
      */
     void* buffer;
 };
  
 MIOPEN_EXPORT miopenStatus_t miopenRunSolution(miopenHandle_t handle,
                                                miopenSolution_t solution,
                                                size_t nInputs,
                                                const miopenTensorArgument_t* tensors,
                                                void* workspace,
                                                size_t workspaceSize);
  
 MIOPEN_EXPORT miopenStatus_t miopenDestroySolution(miopenSolution_t solution);
  
 MIOPEN_EXPORT miopenStatus_t miopenLoadSolution(miopenSolution_t* solution,
                                                 const char* data,
                                                 size_t size);
  
 MIOPEN_EXPORT miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution,
                                                             size_t* workspaceSize);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution,
                                                        uint64_t* solverId);
  
 MIOPEN_EXPORT miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId,
                                                             miopenConvAlgorithm_t* result);
  
 #ifdef MIOPEN_BETA_API
  
 MIOPEN_EXPORT miopenStatus_t
 miopenCreateActivationProblem(miopenProblem_t* problem,
                               miopenActivationDescriptor_t operatorDesc,
                               miopenProblemDirection_t direction);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateBatchnormProblem(miopenProblem_t* problem,
                                                           miopenBatchNormMode_t mode,
                                                           bool runningMeanVariance,
                                                           miopenProblemDirection_t direction);
  
 MIOPEN_EXPORT miopenStatus_t miopenFuseProblems(miopenProblem_t problem1, miopenProblem_t problem2);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateBiasProblem(miopenProblem_t* problem,
                                                      miopenProblemDirection_t direction);
  
 MIOPEN_EXPORT miopenStatus_t miopenCreateSoftmaxProblem(miopenProblem_t* problem,
                                                         miopenSoftmaxDescriptor_t operatorDesc,
                                                         miopenProblemDirection_t direction);
  
 #endif
  
 // CLOSEOUT find2 DOXYGEN GROUP
  
 #ifdef MIOPEN_BETA_API
  
 typedef enum
 {
     MIOPEN_REDUCE_CALCULATION_NOT_PROPAGATE_NAN = 0, 
     MIOPEN_REDUCE_CALCULATION_PROPAGATE_NAN =
         1, 
 } miopenReduceCalculationNanPropagation_t;
  
 // ReduceCalculation APIs
 typedef enum
 {
     MIOPEN_REDUCE_CALCULATION_PROD =
         1, 
     MIOPEN_REDUCE_CALCULATION_SUM =
         2, 
 } miopenReduceCalculationOp_t;
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT REDUCE CALCULATION DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
  
 typedef enum
 {
     MIOPEN_REDUCE_EXTREME_ARGMIN =
         1, 
     MIOPEN_REDUCE_EXTREME_ARGMAX =
         2, 
     MIOPEN_REDUCE_EXTREME_MIN =
         3, 
     MIOPEN_REDUCE_EXTREME_MAX =
         4, 
 } miopenReduceExtremeOp_t;
  
 // ReduceExtreme APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT REDUCEEXTREME DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // GroupNorm APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT groupnorm DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // LayerNorm APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT LAYERNORM DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // LayerNorm APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
 // CLOSEOUT LAYERNORM DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // Graph API
 typedef enum
 {
     MIOPEN_BACKEND_CONVOLUTION_DESCRIPTOR,
     MIOPEN_BACKEND_ENGINE_DESCRIPTOR,
     MIOPEN_BACKEND_ENGINECFG_DESCRIPTOR,
     MIOPEN_BACKEND_ENGINEHEUR_DESCRIPTOR,
     MIOPEN_BACKEND_EXECUTION_PLAN_DESCRIPTOR,
     MIOPEN_BACKEND_INTERMEDIATE_INFO_DESCRIPTOR,
     MIOPEN_BACKEND_KNOB_CHOICE_DESCRIPTOR,
     MIOPEN_BACKEND_KNOB_INFO_DESCRIPTOR,
     MIOPEN_BACKEND_LAYOUT_INFO_DESCRIPTOR,
     MIOPEN_BACKEND_MATMUL_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_CONCAT_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_GEN_STATS_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_MATMUL_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_NORM_BACKWARD_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_NORM_FORWARD_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_POINTWISE_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_REDUCTION_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_RESAMPLE_BWD_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_RESAMPLE_FWD_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_RESHAPE_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_RNG_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATION_SIGNAL_DESCRIPTOR,
     MIOPEN_BACKEND_OPERATIONGRAPH_DESCRIPTOR,
     MIOPEN_BACKEND_POINTWISE_DESCRIPTOR,
     MIOPEN_BACKEND_REDUCTION_DESCRIPTOR,
     MIOPEN_BACKEND_RESAMPLE_DESCRIPTOR,
     MIOPEN_BACKEND_RNG_DESCRIPTOR,
     MIOPEN_BACKEND_TENSOR_DESCRIPTOR,
     MIOPEN_BACKEND_VARIANT_PACK_DESCRIPTOR,
 } miopenBackendDescriptorType_t;
  
 typedef enum
 {
     MIOPEN_ATTR_POINTWISE_MODE                  = 0,
     MIOPEN_ATTR_POINTWISE_MATH_PREC             = 1,
     MIOPEN_ATTR_POINTWISE_NAN_PROPAGATION       = 2,
     MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP       = 3,
     MIOPEN_ATTR_POINTWISE_RELU_UPPER_CLIP       = 4,
     MIOPEN_ATTR_POINTWISE_RELU_LOWER_CLIP_SLOPE = 5,
     MIOPEN_ATTR_POINTWISE_ELU_ALPHA             = 6,
     MIOPEN_ATTR_POINTWISE_SOFTPLUS_BETA         = 7,
     MIOPEN_ATTR_POINTWISE_SWISH_BETA            = 8,
     MIOPEN_ATTR_POINTWISE_AXIS                  = 9,
  
     MIOPEN_ATTR_CONVOLUTION_COMP_TYPE      = 100,
     MIOPEN_ATTR_CONVOLUTION_CONV_MODE      = 101,
     MIOPEN_ATTR_CONVOLUTION_DILATIONS      = 102,
     MIOPEN_ATTR_CONVOLUTION_FILTER_STRIDES = 103,
     MIOPEN_ATTR_CONVOLUTION_POST_PADDINGS  = 104,
     MIOPEN_ATTR_CONVOLUTION_PRE_PADDINGS   = 105,
     MIOPEN_ATTR_CONVOLUTION_SPATIAL_DIMS   = 106,
  
     MIOPEN_ATTR_ENGINEHEUR_MODE            = 200,
     MIOPEN_ATTR_ENGINEHEUR_OPERATION_GRAPH = 201,
     MIOPEN_ATTR_ENGINEHEUR_RESULTS         = 202,
     MIOPEN_ATTR_ENGINEHEUR_SM_COUNT_TARGET = 203,
  
     MIOPEN_ATTR_ENGINECFG_ENGINE            = 300,
     MIOPEN_ATTR_ENGINECFG_INTERMEDIATE_INFO = 301,
     MIOPEN_ATTR_ENGINECFG_KNOB_CHOICES      = 302,
  
     MIOPEN_ATTR_EXECUTION_PLAN_HANDLE                     = 400,
     MIOPEN_ATTR_EXECUTION_PLAN_ENGINE_CONFIG              = 401,
     MIOPEN_ATTR_EXECUTION_PLAN_WORKSPACE_SIZE             = 402,
     MIOPEN_ATTR_EXECUTION_PLAN_COMPUTED_INTERMEDIATE_UIDS = 403,
     MIOPEN_ATTR_EXECUTION_PLAN_RUN_ONLY_INTERMEDIATE_UIDS = 404,
     MIOPEN_ATTR_EXECUTION_PLAN_JSON_REPRESENTATION        = 405,
  
     MIOPEN_ATTR_INTERMEDIATE_INFO_UNIQUE_ID            = 500,
     MIOPEN_ATTR_INTERMEDIATE_INFO_SIZE                 = 501,
     MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_DATA_UIDS  = 502,
     MIOPEN_ATTR_INTERMEDIATE_INFO_DEPENDENT_ATTRIBUTES = 503,
  
     MIOPEN_ATTR_KNOB_CHOICE_KNOB_TYPE  = 600,
     MIOPEN_ATTR_KNOB_CHOICE_KNOB_VALUE = 601,
  
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_ALPHA        = 700,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_BETA         = 701,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_CONV_DESC    = 702,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_W            = 703,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_X            = 704,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_FORWARD_Y            = 705,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_ALPHA       = 706,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_BETA        = 707,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_CONV_DESC   = 708,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_W           = 709,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DX          = 710,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_DATA_DY          = 711,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_ALPHA     = 712,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_BETA      = 713,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_CONV_DESC = 714,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DW        = 715,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_X         = 716,
     MIOPEN_ATTR_OPERATION_CONVOLUTION_BWD_FILTER_DY        = 717,
     MIOPEN_ATTR_OPERATION_POINTWISE_PW_DESCRIPTOR          = 750,
     MIOPEN_ATTR_OPERATION_POINTWISE_XDESC                  = 751,
     MIOPEN_ATTR_OPERATION_POINTWISE_BDESC                  = 752,
     MIOPEN_ATTR_OPERATION_POINTWISE_YDESC                  = 753,
     MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA1                 = 754,
     MIOPEN_ATTR_OPERATION_POINTWISE_ALPHA2                 = 755,
     MIOPEN_ATTR_OPERATION_POINTWISE_DXDESC                 = 756,
     MIOPEN_ATTR_OPERATION_POINTWISE_DYDESC                 = 757,
     MIOPEN_ATTR_OPERATION_POINTWISE_TDESC                  = 758,
  
     MIOPEN_ATTR_OPERATION_GENSTATS_MODE      = 770,
     MIOPEN_ATTR_OPERATION_GENSTATS_MATH_PREC = 771,
     MIOPEN_ATTR_OPERATION_GENSTATS_XDESC     = 772,
     MIOPEN_ATTR_OPERATION_GENSTATS_SUMDESC   = 773,
     MIOPEN_ATTR_OPERATION_GENSTATS_SQSUMDESC = 774,
  
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_STATS_MODE                = 780,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_MATH_PREC                 = 781,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SUM_DESC                = 782,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_Y_SQ_SUM_DESC             = 783,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_SCALE_DESC                = 784,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_BIAS_DESC                 = 785,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_MEAN_DESC    = 786,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_PREV_RUNNING_VAR_DESC     = 787,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_MEAN_DESC = 788,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_UPDATED_RUNNING_VAR_DESC  = 789,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_MEAN_DESC           = 790,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_SAVED_INV_STD_DESC        = 791,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_SCALE_DESC             = 792,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_EQ_BIAS_DESC              = 793,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_ACCUM_COUNT_DESC          = 794,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_EPSILON_DESC              = 795,
     MIOPEN_ATTR_OPERATION_BN_FINALIZE_EXP_AVERATE_FACTOR_DESC   = 796,
  
     MIOPEN_ATTR_OPERATIONGRAPH_HANDLE              = 800,
     MIOPEN_ATTR_OPERATIONGRAPH_OPS                 = 801,
     MIOPEN_ATTR_OPERATIONGRAPH_ENGINE_GLOBAL_COUNT = 802,
  
     MIOPEN_ATTR_TENSOR_BYTE_ALIGNMENT       = 900,
     MIOPEN_ATTR_TENSOR_DATA_TYPE            = 901,
     MIOPEN_ATTR_TENSOR_DIMENSIONS           = 902,
     MIOPEN_ATTR_TENSOR_STRIDES              = 903,
     MIOPEN_ATTR_TENSOR_VECTOR_COUNT         = 904,
     MIOPEN_ATTR_TENSOR_VECTORIZED_DIMENSION = 905,
     MIOPEN_ATTR_TENSOR_UNIQUE_ID            = 906,
     MIOPEN_ATTR_TENSOR_IS_VIRTUAL           = 907,
     MIOPEN_ATTR_TENSOR_IS_BY_VALUE          = 908,
     MIOPEN_ATTR_TENSOR_REORDERING_MODE      = 909,
     MIOPEN_ATTR_TENSOR_RAGGED_OFFSET_DESC   = 910,
  
     MIOPEN_ATTR_VARIANT_PACK_UNIQUE_IDS    = 1000,
     MIOPEN_ATTR_VARIANT_PACK_DATA_POINTERS = 1001,
     MIOPEN_ATTR_VARIANT_PACK_INTERMEDIATES = 1002,
     MIOPEN_ATTR_VARIANT_PACK_WORKSPACE     = 1003,
  
     MIOPEN_ATTR_LAYOUT_INFO_TENSOR_UID = 1100,
     MIOPEN_ATTR_LAYOUT_INFO_TYPES      = 1101,
  
     MIOPEN_ATTR_KNOB_INFO_TYPE          = 1200,
     MIOPEN_ATTR_KNOB_INFO_MAXIMUM_VALUE = 1201,
     MIOPEN_ATTR_KNOB_INFO_MINIMUM_VALUE = 1202,
     MIOPEN_ATTR_KNOB_INFO_STRIDE        = 1203,
  
     MIOPEN_ATTR_ENGINE_OPERATION_GRAPH = 1300,
     MIOPEN_ATTR_ENGINE_GLOBAL_INDEX    = 1301,
     MIOPEN_ATTR_ENGINE_KNOB_INFO       = 1302,
     MIOPEN_ATTR_ENGINE_NUMERICAL_NOTE  = 1303,
     MIOPEN_ATTR_ENGINE_LAYOUT_INFO     = 1304,
     MIOPEN_ATTR_ENGINE_BEHAVIOR_NOTE   = 1305,
     MIOPEN_ATTR_ENGINE_SM_COUNT_TARGET = 1306,
  
     MIOPEN_ATTR_MATMUL_COMP_TYPE     = 1500,
     MIOPEN_ATTR_MATMUL_PADDING_VALUE = 1501,
  
     MIOPEN_ATTR_OPERATION_MATMUL_ADESC                           = 1520,
     MIOPEN_ATTR_OPERATION_MATMUL_BDESC                           = 1521,
     MIOPEN_ATTR_OPERATION_MATMUL_CDESC                           = 1522,
     MIOPEN_ATTR_OPERATION_MATMUL_DESC                            = 1523,
     MIOPEN_ATTR_OPERATION_MATMUL_IRREGULARLY_STRIDED_BATCH_COUNT = 1524,
     MIOPEN_ATTR_OPERATION_MATMUL_GEMM_M_OVERRIDE_DESC            = 1525,
     MIOPEN_ATTR_OPERATION_MATMUL_GEMM_N_OVERRIDE_DESC            = 1526,
     MIOPEN_ATTR_OPERATION_MATMUL_GEMM_K_OVERRIDE_DESC            = 1527,
  
     MIOPEN_ATTR_REDUCTION_OPERATOR  = 1600,
     MIOPEN_ATTR_REDUCTION_COMP_TYPE = 1601,
  
     MIOPEN_ATTR_OPERATION_REDUCTION_XDESC = 1610,
     MIOPEN_ATTR_OPERATION_REDUCTION_YDESC = 1611,
     MIOPEN_ATTR_OPERATION_REDUCTION_DESC  = 1612,
  
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MATH_PREC        = 1620,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_MEAN_DESC        = 1621,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_INVSTD_DESC      = 1622,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_BN_SCALE_DESC    = 1623,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_X_DESC           = 1624,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DY_DESC          = 1625,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_SCALE_DESC   = 1626,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_DBN_BIAS_DESC    = 1627,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_DY_SCALE_DESC = 1628,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_X_SCALE_DESC  = 1629,
     MIOPEN_ATTR_OPERATION_BN_BWD_WEIGHTS_EQ_BIAS          = 1630,
  
     MIOPEN_ATTR_RESAMPLE_MODE            = 1700,
     MIOPEN_ATTR_RESAMPLE_COMP_TYPE       = 1701,
     MIOPEN_ATTR_RESAMPLE_SPATIAL_DIMS    = 1702,
     MIOPEN_ATTR_RESAMPLE_POST_PADDINGS   = 1703,
     MIOPEN_ATTR_RESAMPLE_PRE_PADDINGS    = 1704,
     MIOPEN_ATTR_RESAMPLE_STRIDES         = 1705,
     MIOPEN_ATTR_RESAMPLE_WINDOW_DIMS     = 1706,
     MIOPEN_ATTR_RESAMPLE_NAN_PROPAGATION = 1707,
     MIOPEN_ATTR_RESAMPLE_PADDING_MODE    = 1708,
  
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_XDESC   = 1710,
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_YDESC   = 1711,
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_IDXDESC = 1712,
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_ALPHA   = 1713,
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_BETA    = 1714,
     MIOPEN_ATTR_OPERATION_RESAMPLE_FWD_DESC    = 1716,
  
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DXDESC  = 1720,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DYDESC  = 1721,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_IDXDESC = 1722,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_ALPHA   = 1723,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_BETA    = 1724,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_DESC    = 1725,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_XDESC   = 1726,
     MIOPEN_ATTR_OPERATION_RESAMPLE_BWD_YDESC   = 1727,
  
     MIOPEN_ATTR_OPERATION_CONCAT_AXIS          = 1800,
     MIOPEN_ATTR_OPERATION_CONCAT_INPUT_DESCS   = 1801,
     MIOPEN_ATTR_OPERATION_CONCAT_INPLACE_INDEX = 1802,
     MIOPEN_ATTR_OPERATION_CONCAT_OUTPUT_DESC   = 1803,
  
     MIOPEN_ATTR_OPERATION_SIGNAL_MODE     = 1900,
     MIOPEN_ATTR_OPERATION_SIGNAL_FLAGDESC = 1901,
     MIOPEN_ATTR_OPERATION_SIGNAL_VALUE    = 1902,
     MIOPEN_ATTR_OPERATION_SIGNAL_XDESC    = 1903,
     MIOPEN_ATTR_OPERATION_SIGNAL_YDESC    = 1904,
  
     MIOPEN_ATTR_OPERATION_NORM_FWD_MODE                     = 2000,
     MIOPEN_ATTR_OPERATION_NORM_FWD_PHASE                    = 2001,
     MIOPEN_ATTR_OPERATION_NORM_FWD_XDESC                    = 2002,
     MIOPEN_ATTR_OPERATION_NORM_FWD_MEAN_DESC                = 2003,
     MIOPEN_ATTR_OPERATION_NORM_FWD_INV_VARIANCE_DESC        = 2004,
     MIOPEN_ATTR_OPERATION_NORM_FWD_SCALE_DESC               = 2005,
     MIOPEN_ATTR_OPERATION_NORM_FWD_BIAS_DESC                = 2006,
     MIOPEN_ATTR_OPERATION_NORM_FWD_EPSILON_DESC             = 2007,
     MIOPEN_ATTR_OPERATION_NORM_FWD_EXP_AVG_FACTOR_DESC      = 2008,
     MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_MEAN_DESC  = 2009,
     MIOPEN_ATTR_OPERATION_NORM_FWD_INPUT_RUNNING_VAR_DESC   = 2010,
     MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_MEAN_DESC = 2011,
     MIOPEN_ATTR_OPERATION_NORM_FWD_OUTPUT_RUNNING_VAR_DESC  = 2012,
     MIOPEN_ATTR_OPERATION_NORM_FWD_YDESC                    = 2013,
     MIOPEN_ATTR_OPERATION_NORM_FWD_PEER_STAT_DESCS          = 2014,
  
     MIOPEN_ATTR_OPERATION_NORM_BWD_MODE              = 2100,
     MIOPEN_ATTR_OPERATION_NORM_BWD_XDESC             = 2101,
     MIOPEN_ATTR_OPERATION_NORM_BWD_MEAN_DESC         = 2102,
     MIOPEN_ATTR_OPERATION_NORM_BWD_INV_VARIANCE_DESC = 2103,
     MIOPEN_ATTR_OPERATION_NORM_BWD_DYDESC            = 2104,
     MIOPEN_ATTR_OPERATION_NORM_BWD_SCALE_DESC        = 2105,
     MIOPEN_ATTR_OPERATION_NORM_BWD_EPSILON_DESC      = 2106,
     MIOPEN_ATTR_OPERATION_NORM_BWD_DSCALE_DESC       = 2107,
     MIOPEN_ATTR_OPERATION_NORM_BWD_DBIAS_DESC        = 2108,
     MIOPEN_ATTR_OPERATION_NORM_BWD_DXDESC            = 2109,
     MIOPEN_ATTR_OPERATION_NORM_BWD_PEER_STAT_DESCS   = 2110,
  
     MIOPEN_ATTR_OPERATION_RESHAPE_XDESC = 2200,
     MIOPEN_ATTR_OPERATION_RESHAPE_YDESC = 2201,
  
     MIOPEN_ATTR_RNG_DISTRIBUTION                   = 2300,
     MIOPEN_ATTR_RNG_NORMAL_DIST_MEAN               = 2301,
     MIOPEN_ATTR_RNG_NORMAL_DIST_STANDARD_DEVIATION = 2302,
     MIOPEN_ATTR_RNG_UNIFORM_DIST_MAXIMUM           = 2303,
     MIOPEN_ATTR_RNG_UNIFORM_DIST_MINIMUM           = 2304,
     MIOPEN_ATTR_RNG_BERNOULLI_DIST_PROBABILITY     = 2305,
  
     MIOPEN_ATTR_OPERATION_RNG_YDESC       = 2310,
     MIOPEN_ATTR_OPERATION_RNG_SEED        = 2311,
     MIOPEN_ATTR_OPERATION_RNG_DESC        = 2312,
     MIOPEN_ATTR_OPERATION_RNG_OFFSET_DESC = 2313,
  
 } miopenBackendAttributeName_t;
  
 typedef enum
 {
     MIOPEN_TYPE_HANDLE = 0,              
     MIOPEN_TYPE_DATA_TYPE,               
     MIOPEN_TYPE_BOOLEAN,                 
     MIOPEN_TYPE_INT64,                   
     MIOPEN_TYPE_FLOAT,                   
     MIOPEN_TYPE_DOUBLE,                  
     MIOPEN_TYPE_VOID_PTR,                
     MIOPEN_TYPE_CONVOLUTION_MODE,        
     MIOPEN_TYPE_HEUR_MODE,               
     MIOPEN_TYPE_KNOB_TYPE,               
     MIOPEN_TYPE_NAN_PROPOGATION,         
     MIOPEN_TYPE_NUMERICAL_NOTE,          
     MIOPEN_TYPE_LAYOUT_TYPE,             
     MIOPEN_TYPE_ATTRIB_NAME,             
     MIOPEN_TYPE_POINTWISE_MODE,          
     MIOPEN_TYPE_BACKEND_DESCRIPTOR,      
     MIOPEN_TYPE_GENSTATS_MODE,           
     MIOPEN_TYPE_BN_FINALIZE_STATS_MODE,  
     MIOPEN_TYPE_REDUCTION_OPERATOR_TYPE, 
     MIOPEN_TYPE_BEHAVIOR_NOTE,           
     MIOPEN_TYPE_TENSOR_REORDERING_MODE,  
     MIOPEN_TYPE_RESAMPLE_MODE,           
     MIOPEN_TYPE_PADDING_MODE,            
     MIOPEN_TYPE_INT32,                   
     MIOPEN_TYPE_CHAR,                    
     MIOPEN_TYPE_SIGNAL_MODE,             
     MIOPEN_TYPE_FRACTION,                
     MIOPEN_TYPE_NORM_MODE,               
     MIOPEN_TYPE_NORM_FWD_PHASE,          
     MIOPEN_TYPE_RNG_DISTRIBUTION         
 } miopenBackendAttributeType_t;
  
 typedef enum
 {
     MIOPEN_POINTWISE_ADD,
  
     MIOPEN_POINTWISE_ADD_SQUARE,
  
     MIOPEN_POINTWISE_DIV,
  
     MIOPEN_POINTWISE_MAX,
  
     MIOPEN_POINTWISE_MIN,
  
     MIOPEN_POINTWISE_MOD,
  
     MIOPEN_POINTWISE_MUL,
  
     MIOPEN_POINTWISE_POW,
  
     MIOPEN_POINTWISE_SUB,
  
     MIOPEN_POINTWISE_ABS,
  
     MIOPEN_POINTWISE_CEIL,
  
     MIOPEN_POINTWISE_COS,
  
     MIOPEN_POINTWISE_EXP,
  
     MIOPEN_POINTWISE_FLOOR,
  
     MIOPEN_POINTWISE_LOG,
  
     MIOPEN_POINTWISE_NEG,
  
     MIOPEN_POINTWISE_RSQRT,
  
     MIOPEN_POINTWISE_SIN,
  
     MIOPEN_POINTWISE_SQRT,
  
     MIOPEN_POINTWISE_TAN,
  
     MIOPEN_POINTWISE_ERF,
  
     MIOPEN_POINTWISE_IDENTITY,
  
     MIOPEN_POINTWISE_RELU_FWD,
  
     MIOPEN_POINTWISE_TANH_FWD,
  
     MIOPEN_POINTWISE_SIGMOID_FWD,
  
     MIOPEN_POINTWISE_ELU_FWD,
  
     MIOPEN_POINTWISE_GELU_FWD,
  
     MIOPEN_POINTWISE_SOFTPLUS_FWD,
  
     MIOPEN_POINTWISE_SWISH_FWD,
  
     MIOPEN_POINTWISE_GELU_APPROX_TANH_FWD,
  
     MIOPEN_POINTWISE_RELU_BWD,
  
     MIOPEN_POINTWISE_TANH_BWD,
  
     MIOPEN_POINTWISE_SIGMOID_BWD,
  
     MIOPEN_POINTWISE_ELU_BWD,
  
     MIOPEN_POINTWISE_GELU_BWD,
  
     MIOPEN_POINTWISE_SOFTPLUS_BWD,
  
     MIOPEN_POINTWISE_SWISH_BWD,
  
     MIOPEN_POINTWISE_GELU_APPROX_TANH_BWD,
  
     MIOPEN_POINTWISE_CMP_EQ,
  
     MIOPEN_POINTWISE_CMP_NEQ,
  
     MIOPEN_POINTWISE_CMP_GT,
  
     MIOPEN_POINTWISE_CMP_GE,
  
     MIOPEN_POINTWISE_CMP_LT,
  
     MIOPEN_POINTWISE_CMP_LE,
  
     MIOPEN_POINTWISE_LOGICAL_AND,
  
     MIOPEN_POINTWISE_LOGICAL_OR,
  
     MIOPEN_POINTWISE_LOGICAL_NOT,
  
     MIOPEN_POINTWISE_GEN_INDEX,
  
     MIOPEN_POINTWISE_BINARY_SELECT,
  
     MIOPEN_POINTWISE_RECIPROCAL
 } miopenPointwiseMode_t;
  
 typedef enum
 {
     MIOPEN_RNG_DISTRIBUTION_BERNOULLI,
     MIOPEN_RNG_DISTRIBUTION_UNIFORM,
     MIOPEN_RNG_DISTRIBUTION_NORMAL,
 } miopenRngDistribution_t;
  
 typedef enum
 {
     /* IDENTITY      alpha = 1.0 and beta = 0.0 */
     /* SCALE         alpha = 4.2 and beta = 0.0 */
     /* BILINEAR      alpha = 3.2 and beta = 1.1 */
     /* ERROR_STATE   alpha = 0.0 and beta = 3.1 */
  
     DEFAULT     = 0, /* alpha = 1.0 and beta = 0.0.*/
     SCALE       = 1, /* alpha with some value and beta 0.0*/
     BILINEAR    = 2, /* both alpha and beta with some value*/
     ERROR_STATE = 3, /* alpha 0.0 and beta with some value, this should not occur.
                         But used to check for errors.*/
 } miopenAlphaBetaCase_t;
 typedef enum
 {
     MIOPEN_HEUR_MODE_INSTANT  = 0,
     MIOPEN_HEUR_MODE_B        = 1,
     MIOPEN_HEUR_MODE_FALLBACK = 2,
     MIOPEN_HEUR_MODE_A        = 3,
     MIOPEN_HEUR_MODES_COUNT   = 4,
 } miopenBackendHeurMode_t;
  
 MIOPEN_DECLARE_OBJECT(miopenBackendDescriptor)
  
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendCreateDescriptor(
     miopenBackendDescriptorType_t descriptorType, miopenBackendDescriptor_t* descriptor);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendSetAttribute(miopenBackendDescriptor_t descriptor,
                                                        miopenBackendAttributeName_t attributeName,
                                                        miopenBackendAttributeType_t attributeType,
                                                        int64_t elementCount,
                                                        void* arrayOfElements);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendFinalize(miopenBackendDescriptor_t descriptor);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendGetAttribute(miopenBackendDescriptor_t descriptor,
                                                        miopenBackendAttributeName_t attributeName,
                                                        miopenBackendAttributeType_t attributeType,
                                                        int64_t requestedElementCount,
                                                        int64_t* elementCount,
                                                        void* arrayOfElements);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendExecute(miopenHandle_t handle,
                                                   miopenBackendDescriptor_t executionPlan,
                                                   miopenBackendDescriptor_t variantPack);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendDestroyDescriptor(miopenBackendDescriptor_t descriptor);
  
 MIOPEN_EXPORT miopenStatus_t miopenBackendInitialize(miopenBackendDescriptor_t descriptor,
                                                      miopenBackendDescriptorType_t descriptorType,
                                                      size_t sizeInBytes);
  
 // CLOSEOUT BackendAPI DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // FusedAdam APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT SGD DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // TransformersAdamW APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT SGD DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // GetItem APIs
 MIOPEN_EXPORT miopenStatus_t
 miopenGetGetitemWorkspaceSize(miopenHandle_t handle,
                               uint32_t indexCount,
                               const miopenTensorDescriptor_t* indexDescs,
                               size_t* sizeInBytes);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT GETITEM DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 // RotaryPositionalEmbeddings APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
 // CLOSEOUT ROPE DOXYGEN GROUP
 // kthvalue APIs
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT kthvalue DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
 MIOPEN_EXPORT miopenStatus_t
 miopenGetPReLUBackwardWorkspaceSize(miopenHandle_t handle,
                                     miopenTensorDescriptor_t inputDesc,
                                     miopenTensorDescriptor_t weightDesc,
                                     size_t* sizeInBytes);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT RELU DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef MIOPEN_BETA_API
  
 typedef enum
 {
     MIOPEN_LOSS_REDUCTION_NONE = 0, 
     MIOPEN_LOSS_REDUCTION_SUM  = 1, 
     MIOPEN_LOSS_REDUCTION_MEAN = 2, 
 } miopenLossReductionMode_t;
  
 // SoftMarginLoss APIs
 MIOPEN_EXPORT miopenStatus_t
 miopenGetSoftMarginLossForwardWorkspaceSize(miopenHandle_t handle,
                                             miopenTensorDescriptor_t inputDesc,
                                             miopenTensorDescriptor_t targetDesc,
                                             miopenTensorDescriptor_t outputDesc,
                                             miopenLossReductionMode_t reduction,
                                             size_t* sizeInBytes);
  
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT LossFunction DOXYGEN GROUP
 #endif
  
 #ifdef MIOPEN_BETA_API
 // MultiMarginLoss APIs
 MIOPEN_EXPORT 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);
  
 MIOPEN_EXPORT 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);
  
 // CLOSEOUT LossFunction DOXYGEN GROUP
 #endif // MIOPEN_BETA_API
  
 #ifdef __cplusplus
 }
 #endif
  
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
  
 #endif // MIOPEN_GUARD_MIOPEN_H_