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

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rpp/checkouts/develop/include/rppdefs.h Source File#

RPP: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rpp/checkouts/develop/include/rppdefs.h Source File
Go to the documentation of this file.
 /*
 MIT License
  
 Copyright (c) 2019 - 2024 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 RPPDEFS_H
 #define RPPDEFS_H
  
 #include <stddef.h>
 #include <cmath>
 #ifdef HIP_COMPILE
     #include <hip/hip_fp16.h>
 #endif // HIP_COMPILE
 #include <half/half.hpp>
 using halfhpp = half_float::half;
 typedef halfhpp Rpp16f;
  
 #ifdef OCL_COMPILE
 #include <CL/cl.h>
 #endif
  
 #if _WIN32
 #include <intrin.h>
 #else
 #include <x86intrin.h>
 #include <smmintrin.h>
 #include <immintrin.h>
 #endif
 #include<vector>
  
 #define RPP_MIN_8U      ( 0 )
 #define RPP_MAX_8U      ( 255 )
 #define RPPT_MAX_DIMS   ( 5 )
 #define RPPT_MAX_AUDIO_CHANNELS   ( 16 )
  
 #define CHECK_RETURN_STATUS(x) do { \
   int retval = (x); \
   if (retval != 0) { \
     fprintf(stderr, "Runtime error: %s returned %d at %s:%d", #x, retval, __FILE__, __LINE__); \
     exit(-1); \
   } \
 } while (0)
  
 #ifdef HIP_COMPILE
 #include <hip/hip_runtime.h>
 #define RPP_HOST_DEVICE __host__ __device__
 #else
 #define RPP_HOST_DEVICE
 #endif
  
 const float ONE_OVER_6                      = 1.0f / 6;
 const float ONE_OVER_3                      = 1.0f / 3;
 const float ONE_OVER_255                    = 1.0f / 255;
 const uint MMS_MAX_SCRATCH_MEMORY           = 115293120; // maximum scratch memory size (in number of floats) needed for MMS buffer in RNNT training
 const uint SPECTROGRAM_MAX_SCRATCH_MEMORY   = 372877312; // maximum scratch memory size (in number of floats) needed for spectrogram HIP kernel in RNNT training
  
 /******************** RPP typedefs ********************/
  
 typedef unsigned char       Rpp8u;
 typedef signed char         Rpp8s;
 typedef unsigned short      Rpp16u;
 typedef short               Rpp16s;
 typedef unsigned int        Rpp32u;
 typedef int                 Rpp32s;
 typedef unsigned long long  Rpp64u;
 typedef long long           Rpp64s;
 typedef float               Rpp32f;
 typedef double              Rpp64f;
 typedef void*               RppPtr_t;
 typedef size_t              RppSize_t;
  
 typedef enum
 {
     RPP_SUCCESS                         = 0,
     RPP_ERROR                           = -1,
     RPP_ERROR_INVALID_ARGUMENTS         = -2,
     RPP_ERROR_LOW_OFFSET                = -3,
     RPP_ERROR_ZERO_DIVISION             = -4,
     RPP_ERROR_HIGH_SRC_DIMENSION        = -5,
     RPP_ERROR_NOT_IMPLEMENTED           = -6,
     RPP_ERROR_INVALID_SRC_CHANNELS      = -7,
     RPP_ERROR_INVALID_DST_CHANNELS      = -8,
     RPP_ERROR_INVALID_SRC_LAYOUT        = -9,
     RPP_ERROR_INVALID_DST_LAYOUT        = -10,
     RPP_ERROR_INVALID_SRC_DATATYPE      = -11,
     RPP_ERROR_INVALID_DST_DATATYPE      = -12,
     RPP_ERROR_INVALID_SRC_OR_DST_DATATYPE       = -13,
     RPP_ERROR_INSUFFICIENT_DST_BUFFER_LENGTH    = -14,
     RPP_ERROR_INVALID_PARAMETER_DATATYPE        = -15,
     RPP_ERROR_NOT_ENOUGH_MEMORY         = -16,
     RPP_ERROR_OUT_OF_BOUND_SRC_ROI      = -17,
     RPP_ERROR_LAYOUT_MISMATCH           = -18,
     RPP_ERROR_INVALID_CHANNELS          = -19,
     RPP_ERROR_INVALID_OUTPUT_TILE_LENGTH    = -20,
     RPP_ERROR_OUT_OF_BOUND_SHARED_MEMORY_SIZE    = -21,
     RPP_ERROR_OUT_OF_BOUND_SCRATCH_MEMORY_SIZE    = -22,
     RPP_ERROR_INVALID_SRC_DIMS          = -23,
     RPP_ERROR_INVALID_DST_DIMS          = -24
 } RppStatus;
  
 typedef enum
 {
     rppStatusSuccess        = 0,
     rppStatusBadParm        = -1,
     rppStatusUnknownError   = -2,
     rppStatusNotInitialized = -3,
     rppStatusInvalidValue   = -4,
     rppStatusAllocFailed    = -5,
     rppStatusInternalError  = -6,
     rppStatusNotImplemented = -7,
     rppStatusUnsupportedOp  = -8,
 } rppStatus_t;
  
 typedef enum
 {
     RPP_SCALAR_OP_AND       = 1,
     RPP_SCALAR_OP_OR,
     RPP_SCALAR_OP_XOR,
     RPP_SCALAR_OP_NAND,
     RPP_SCALAR_OP_EQUAL,
     RPP_SCALAR_OP_NOTEQUAL,
     RPP_SCALAR_OP_LESS,
     RPP_SCALAR_OP_LESSEQ,
     RPP_SCALAR_OP_GREATER,
     RPP_SCALAR_OP_GREATEREQ,
     RPP_SCALAR_OP_ADD,
     RPP_SCALAR_OP_SUBTRACT,
     RPP_SCALAR_OP_MULTIPLY,
     RPP_SCALAR_OP_DIVIDE,
     RPP_SCALAR_OP_MODULUS,
     RPP_SCALAR_OP_MIN,
     RPP_SCALAR_OP_MAX,
 } RppOp;
  
 typedef enum
 {
     U8_S8,
     S8_U8,
 } RppConvertBitDepthMode;
  
 typedef struct
 {
     Rpp32f rho;
     Rpp32f theta;
 } RppPointPolar;
  
 typedef struct
 {
     Rpp32u channelParam;
     Rpp32u bufferMultiplier;
 } RppLayoutParams;
  
 typedef struct
 {
     Rpp32f data[6];
 } Rpp32f6;
  
 typedef struct
 {
     Rpp32f data[9];
 } Rpp32f9;
  
 typedef struct
 {
     Rpp32s data[24];
 } Rpp32s24;
  
 typedef struct
 {
     Rpp32f data[24];
 } Rpp32f24;
  
 /******************** RPPI typedefs ********************/
  
 typedef enum
 {
     RGB_HSV                 = 1,
     HSV_RGB
 } RppiColorConvertMode;
  
 typedef enum
 {
     RPPI_LOW,
     RPPI_MEDIUM,
     RPPI_HIGH
 } RppiFuzzyLevel;
  
 typedef enum
 {
     RPPI_CHN_PLANAR,
     RPPI_CHN_PACKED
 } RppiChnFormat;
  
 typedef enum
 {
     RPPI_HORIZONTAL_AXIS,
     RPPI_VERTICAL_AXIS,
     RPPI_BOTH_AXIS
 } RppiAxis;
  
 typedef enum
 {
     GAUSS3,
     GAUSS5,
     GAUSS3x1,
     GAUSS1x3,
     AVG3 = 10,
     AVG5
 } RppiBlur;
  
 typedef enum
 {
     ZEROPAD,
     NOPAD
 } RppiPad;
  
 typedef enum
 {
     RGB,
     HSV
 } RppiFormat;
  
 typedef struct
 {
     unsigned int width;
     unsigned int height;
 } RppiSize;
  
 typedef struct
 {
     int x;
     int y;
 } RppiPoint;
  
 typedef struct
 {
     int x;
     int y;
     int z;
 } RppiPoint3D;
  
 typedef struct
 {
     int x;
     int y;
     int width;
     int height;
 } RppiRect;
  
 typedef struct
 {
     unsigned int x;
     unsigned int y;
     unsigned int roiWidth;
     unsigned int roiHeight;
 } RppiROI;
  
 /******************** RPPT typedefs ********************/
  
 typedef enum
 {
     U8,
     F32,
     F16,
     I8
 } RpptDataType;
  
 typedef enum
 {
     NCHW,   // BatchSize-Channels-Height-Width
     NHWC,   // BatchSize-Height-Width-Channels
     NCDHW,  // BatchSize-Channels-Depth-Height-Width
     NDHWC,  // BatchSize-Depth-Height-Width-Channels
     NHW,    // BatchSize-Height-Width
     NFT,    // BatchSize-Frequency-Time -> Frequency Major used for Spectrogram / MelfilterBank
     NTF     // BatchSize-Time-Frequency -> Time Major used for Spectrogram / MelfilterBank
 } RpptLayout;
  
 typedef enum
 {
     LTRB,    // Left-Top-Right-Bottom
     XYWH     // X-Y-Width-Height
 } RpptRoiType;
  
 typedef enum
 {
     LTFRBB,    // Left-Top-Front-Right-Bottom-Back
     XYZWHD     // X-Y-Z-Width-Height-Depth
 } RpptRoi3DType;
  
 typedef enum
 {
     RGBtype,
     BGRtype
 } RpptSubpixelLayout;
  
 typedef enum
 {
     NEAREST_NEIGHBOR = 0,
     BILINEAR,
     BICUBIC,
     LANCZOS,
     GAUSSIAN,
     TRIANGULAR
 } RpptInterpolationType;
  
 typedef enum
 {
     ZERO = 0,
     CLAMP,
     REFLECT
 } RpptAudioBorderType;
  
 typedef enum
 {
     SLANEY = 0,  // Follows Slaney’s MATLAB Auditory Modelling Work behavior
     HTK,         // Follows O’Shaughnessy’s book formula, consistent with Hidden Markov Toolkit(HTK), m = 2595 * log10(1 + (f/700))
 } RpptMelScaleFormula;
  
 typedef struct
 {
     RppiPoint lt, rb;    // Left-Top point and Right-Bottom point
  
 } RpptRoiLtrb;
  
 typedef struct
 {
     RppiPoint r;
     RppiPoint g;
     RppiPoint b;
 } RpptChannelOffsets;
  
 typedef struct
 {
     RppiPoint3D ltf, rbb; // Left-Top-Front point and Right-Bottom-Back point
  
 } RpptRoiLtfrbb;
  
 typedef struct
 {
     RppiPoint xy;
     int roiWidth, roiHeight;
  
 } RpptRoiXywh;
  
 typedef struct
 {
     RppiPoint3D xyz;
     int roiWidth, roiHeight, roiDepth;
  
 } RpptRoiXyzwhd;
  
 typedef union
 {
     RpptRoiLtrb ltrbROI;    // ROI defined as Left-Top-Right-Bottom
     RpptRoiXywh xywhROI;    // ROI defined as X-Y-Width-Height
  
 } RpptROI, *RpptROIPtr;
  
 typedef union
 {
     RpptRoiLtfrbb ltfrbbROI;    // ROI defined as Left-Top-Front-Right-Bottom-Back
     RpptRoiXyzwhd xyzwhdROI;    // ROI defined as X-Y-Z-Width-Height-Depth
  
 } RpptROI3D, *RpptROI3DPtr;
  
 typedef struct
 {
     Rpp32u nStride;
     Rpp32u cStride;
     Rpp32u hStride;
     Rpp32u wStride;
 } RpptStrides;
  
 typedef struct
 {
     RppSize_t numDims;
     Rpp32u offsetInBytes;
     RpptDataType dataType;
     Rpp32u n, c, h, w;
     RpptStrides strides;
     RpptLayout layout;
 } RpptDesc, *RpptDescPtr;
  
 typedef struct
 {
     RppSize_t numDims;
     Rpp32u offsetInBytes;
     RpptDataType dataType;
     Rpp32u dims[RPPT_MAX_DIMS];
     Rpp32u strides[RPPT_MAX_DIMS];
     RpptLayout layout;
 } RpptGenericDesc, *RpptGenericDescPtr;
  
 typedef struct
 {
     Rpp8u R;
     Rpp8u G;
     Rpp8u B;
 } RpptRGB;
  
 typedef struct
 {
     Rpp32f R;
     Rpp32f G;
     Rpp32f B;
 } RpptFloatRGB;
  
 typedef struct
 {
     Rpp32u x;
     Rpp32u y;
 } RpptUintVector2D;
  
 typedef struct
 {
     Rpp32f x;
     Rpp32f y;
 } RpptFloatVector2D;
  
 typedef struct
 {
     Rpp32u width;
     Rpp32u height;
 } RpptImagePatch, *RpptImagePatchPtr;
  
 typedef struct
 {   Rpp32u x[5];
     Rpp32u counter;
 } RpptXorwowState;
  
 typedef struct
 {   Rpp32s x[5];
     Rpp32s counter;
     int boxMullerFlag;
     float boxMullerExtra;
 } RpptXorwowStateBoxMuller;
  
 typedef struct
 {
     Rpp32s24 srcLocsTL;
     Rpp32s24 srcLocsTR;
     Rpp32s24 srcLocsBL;
     Rpp32s24 srcLocsBR;
 } RpptBilinearNbhoodLocsVecLen8;
  
 typedef struct
 {
     Rpp32f24 srcValsTL;
     Rpp32f24 srcValsTR;
     Rpp32f24 srcValsBL;
     Rpp32f24 srcValsBR;
 } RpptBilinearNbhoodValsVecLen8;
  
 typedef struct GenericFilter
 {
     Rpp32f scale = 1.0f;
     Rpp32f radius = 1.0f;
     Rpp32s size;
     GenericFilter(RpptInterpolationType interpolationType, Rpp32s in_size, Rpp32s out_size, Rpp32f scaleRatio)
     {
         switch(interpolationType)
         {
         case RpptInterpolationType::BICUBIC:
         {
             this->radius = 2.0f;
             break;
         }
         case RpptInterpolationType::LANCZOS:
         {
             if(in_size > out_size)
             {
                 this->radius = 3.0f * scaleRatio;
                 this->scale = (1 / scaleRatio);
             }
             else
                 this->radius = 3.0f;
             break;
         }
         case RpptInterpolationType::GAUSSIAN:
         {
             if(in_size > out_size)
             {
                 this->radius = scaleRatio;
                 this->scale = (1 / scaleRatio);
             }
             break;
         }
         case RpptInterpolationType::TRIANGULAR:
         {
             if(in_size > out_size)
             {
                 this->radius = scaleRatio;
                 this->scale = (1 / scaleRatio);
             }
             break;
         }
         default:
         {
             this->radius = 1.0f;
             this->scale = 1.0f;
             break;
         }
         }
         this->size = std::ceil(2 * this->radius);
     }
 }GenericFilter;
  
 typedef struct RpptResamplingWindow
 {
     inline RPP_HOST_DEVICE void input_range(Rpp32f x, Rpp32s *loc0, Rpp32s *loc1)
     {
         Rpp32s xc = std::ceil(x);
         *loc0 = xc - lobes;
         *loc1 = xc + lobes;
     }
  
     inline Rpp32f operator()(Rpp32f x)
     {
         Rpp32f locRaw = x * scale + center;
         Rpp32s locFloor = std::floor(locRaw);
         Rpp32f weight = locRaw - locFloor;
         locFloor = std::max(std::min(locFloor, lookupSize - 2), 0);
         Rpp32f current = lookup[locFloor];
         Rpp32f next = lookup[locFloor + 1];
         return current + weight * (next - current);
     }
  
     inline __m128 operator()(__m128 x)
     {
         __m128 pLocRaw = _mm_add_ps(_mm_mul_ps(x, pScale), pCenter);
         __m128i pxLocFloor = _mm_cvttps_epi32(pLocRaw);
         __m128 pLocFloor = _mm_cvtepi32_ps(pxLocFloor);
         __m128 pWeight = _mm_sub_ps(pLocRaw, pLocFloor);
         Rpp32s idx[4];
         _mm_storeu_si128(reinterpret_cast<__m128i*>(idx), pxLocFloor);
         __m128 pCurrent = _mm_setr_ps(lookup[idx[0]], lookup[idx[1]], lookup[idx[2]], lookup[idx[3]]);
         __m128 pNext = _mm_setr_ps(lookup[idx[0] + 1], lookup[idx[1] + 1], lookup[idx[2] + 1], lookup[idx[3] + 1]);
         return _mm_add_ps(pCurrent, _mm_mul_ps(pWeight, _mm_sub_ps(pNext, pCurrent)));
     }
  
     Rpp32f scale = 1, center = 1;
     Rpp32s lobes = 0, coeffs = 0;
     Rpp32s lookupSize = 0;
     Rpp32f *lookupPinned = nullptr;
     std::vector<Rpp32f> lookup;
     __m128 pCenter, pScale;
 } RpptResamplingWindow;
  
 struct BaseMelScale
 {
     public:
         inline RPP_HOST_DEVICE virtual Rpp32f hz_to_mel(Rpp32f hz) = 0;
         inline RPP_HOST_DEVICE virtual Rpp32f mel_to_hz(Rpp32f mel) = 0;
         virtual ~BaseMelScale() = default;
 };
  
 struct HtkMelScale : public BaseMelScale
 {
     inline RPP_HOST_DEVICE Rpp32f hz_to_mel(Rpp32f hz) { return 1127.0f * std::log(1.0f + (hz / 700.0f)); }
     inline RPP_HOST_DEVICE Rpp32f mel_to_hz(Rpp32f mel) { return 700.0f * (std::exp(mel / 1127.0f) - 1.0f); }
     public:
         ~HtkMelScale() {};
 };
  
 struct SlaneyMelScale : public BaseMelScale
 {
     const Rpp32f freqLow = 0;
     const Rpp32f fsp = 66.666667f;
     const Rpp32f minLogHz = 1000.0;
     const Rpp32f minLogMel = (minLogHz - freqLow) / fsp;
     const Rpp32f stepLog = 0.068751777;  // Equivalent to std::log(6.4) / 27.0;
  
     const Rpp32f invMinLogHz = 0.001f;
     const Rpp32f invStepLog = 1.0f / stepLog;
     const Rpp32f invFsp = 1.0f / fsp;
  
     inline RPP_HOST_DEVICE Rpp32f hz_to_mel(Rpp32f hz)
     {
         Rpp32f mel = 0.0f;
         if (hz >= minLogHz)
             mel = minLogMel + std::log(hz * invMinLogHz) * invStepLog;
         else
             mel = (hz - freqLow) * invFsp;
  
         return mel;
     }
  
     inline RPP_HOST_DEVICE Rpp32f mel_to_hz(Rpp32f mel)
     {
         Rpp32f hz = 0.0f;
         if (mel >= minLogMel)
             hz = minLogHz * std::exp(stepLog * (mel - minLogMel));
         else
             hz = freqLow + mel * fsp;
         return hz;
     }
     public:
         ~SlaneyMelScale() {};
 };
  
 /******************** HOST memory typedefs ********************/
  
 typedef struct
 {
     Rpp32f *floatmem;
 } memRpp32f;
  
 typedef struct
 {
     Rpp64f *doublemem;
 } memRpp64f;
  
 typedef struct
 {
     Rpp32u *uintmem;
 } memRpp32u;
  
 typedef struct
 {
     Rpp32s *intmem;
 } memRpp32s;
  
 typedef struct
 {
     Rpp8u *ucharmem;
 } memRpp8u;
  
 typedef struct
 {
     Rpp8s *charmem;
 } memRpp8s;
  
 typedef struct
 {
     RpptRGB* rgbmem;
 } memRpptRGB;
  
 typedef struct
 {
     Rpp32u *height;
     Rpp32u *width;
 } memSize;
  
 typedef struct
 {
     Rpp32u *x;
     Rpp32u *y;
     Rpp32u *roiHeight;
     Rpp32u *roiWidth;
 } memROI;
  
 typedef struct {
     RppiSize *srcSize;
     RppiSize *dstSize;
     RppiSize *maxSrcSize;
     RppiSize *maxDstSize;
     RppiROI *roiPoints;
     memRpp32f floatArr[10];
     memRpp64f doubleArr[10];
     memRpp32u uintArr[10];
     memRpp32s intArr[10];
     memRpp8u ucharArr[10];
     memRpp8s charArr[10];
     memRpptRGB rgbArr;
     Rpp64u *srcBatchIndex;
     Rpp64u *dstBatchIndex;
     Rpp32u *inc;
     Rpp32u *dstInc;
     Rpp32f *scratchBufferHost;
 } memCPU;
  
 #ifdef OCL_COMPILE
  
 /******************** OCL memory typedefs ********************/
  
 typedef struct
 {
     cl_mem floatmem;
 } clmemRpp32f;
  
 typedef struct
 {
     cl_mem doublemem;
 } clmemRpp64f;
  
 typedef struct
 {
     cl_mem uintmem;
 } clmemRpp32u;
  
 typedef struct
 {
     cl_mem intmem;
 } clmemRpp32s;
  
 typedef struct
 {
     cl_mem ucharmem;
 } clmemRpp8u;
  
 typedef struct
 {
     cl_mem charmem;
 } clmemRpp8s;
  
 typedef struct
 {
     cl_mem height;
     cl_mem width;
 } clmemSize;
  
 typedef struct
 {
     cl_mem x;
     cl_mem y;
     cl_mem roiHeight;
     cl_mem roiWidth;
 } clmemROI;
  
 typedef struct
 {
     memSize csrcSize;
     memSize cdstSize;
     memSize cmaxSrcSize;
     memSize cmaxDstSize;
     memROI croiPoints;
     clmemSize srcSize;
     clmemSize dstSize;
     clmemSize maxSrcSize;
     clmemSize maxDstSize;
     clmemROI roiPoints;
     clmemRpp32f floatArr[10];
     clmemRpp64f doubleArr[10];
     clmemRpp32u uintArr[10];
     clmemRpp32s intArr[10];
     clmemRpp8u ucharArr[10];
     clmemRpp8s charArr[10];
     cl_mem srcBatchIndex;
     cl_mem dstBatchIndex;
     cl_mem inc;
     cl_mem dstInc;
 } memGPU;
  
 typedef struct
 {
     memCPU mcpu;
     memGPU mgpu;
 } memMgmt;
  
 #elif defined(HIP_COMPILE)
  
 /******************** HIP memory typedefs ********************/
  
 typedef struct
 {
     Rpp32f* floatmem;
 } hipMemRpp32f;
  
 typedef struct
 {
     Rpp64f* doublemem;
 } hipMemRpp64f;
  
 typedef struct
 {
     Rpp32u* uintmem;
 } hipMemRpp32u;
  
 typedef struct
 {
     Rpp32s* intmem;
 } hipMemRpp32s;
  
 typedef struct
 {
     Rpp8u* ucharmem;
 } hipMemRpp8u;
  
 typedef struct
 {
     Rpp8s* charmem;
 } hipMemRpp8s;
  
 typedef struct
 {
     RpptRGB* rgbmem;
 } hipMemRpptRGB;
  
 typedef struct
 {
     Rpp32u* height;
     Rpp32u* width;
 } hipMemSize;
  
 typedef struct
 {
     Rpp32u* x;
     Rpp32u* y;
     Rpp32u* roiHeight;
     Rpp32u* roiWidth;
 } hipMemROI;
  
 typedef struct
 {
     memSize csrcSize;
     memSize cdstSize;
     memSize cmaxSrcSize;
     memSize cmaxDstSize;
     memROI croiPoints;
     hipMemSize srcSize;
     hipMemSize dstSize;
     hipMemSize maxSrcSize;
     hipMemSize maxDstSize;
     hipMemROI roiPoints;
     hipMemRpp32f floatArr[10];
     hipMemRpp32f float3Arr[10];
     hipMemRpp64f doubleArr[10];
     hipMemRpp32u uintArr[10];
     hipMemRpp32s intArr[10];
     hipMemRpp8u ucharArr[10];
     hipMemRpp8s charArr[10];
     hipMemRpptRGB rgbArr;
     hipMemRpp32f scratchBufferHip;
     Rpp64u* srcBatchIndex;
     Rpp64u* dstBatchIndex;
     Rpp32u* inc;
     Rpp32u* dstInc;
     hipMemRpp32f scratchBufferPinned;
 } memGPU;
  
 typedef struct
 {
     memCPU mcpu;
     memGPU mgpu;
 } memMgmt;
  
 #else
  
 typedef struct
 {
     memCPU mcpu;
 } memMgmt;
  
 #endif //BACKEND
  
 typedef struct
 {
     RppPtr_t cpuHandle;
     Rpp32u nbatchSize;
     memMgmt mem;
 } InitHandle;
  
 #endif /* RPPDEFS_H */