/build/reproducible-path/miopen-6.4.3+dfsg/include/miopen/miopen.h Source File

/build/reproducible-path/miopen-6.4.3+dfsg/include/miopen/miopen.h Source File#

MIOpen: /build/reproducible-path/miopen-6.4.3+dfsg/include/miopen/miopen.h Source 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_