// This file is a stub header file of cuda for Read the Docs.

#ifndef INCLUDE_GUARD_STUB_CUPY_CUDA_COMMON_H
#define INCLUDE_GUARD_STUB_CUPY_CUDA_COMMON_H

#define CUDA_VERSION 0

extern "C" {

///////////////////////////////////////////////////////////////////////////////
// cuda.h
///////////////////////////////////////////////////////////////////////////////

typedef int CUdevice;
typedef enum {
    CUDA_SUCCESS = 0,
} CUresult;
enum CUjit_option {};
enum CUjitInputType {};
enum CUfunction_attribute {};;
enum CUarray_format {};
enum CUaddress_mode {};
enum CUfilter_mode {};


typedef void* CUdeviceptr;
struct CUctx_st;
struct CUevent_st;
struct CUfunc_st;
struct CUmod_st;
struct CUstream_st;
struct CUgraph_st;
struct CUgraphExec_st;
struct CUlinkState_st;


typedef struct CUctx_st* CUcontext;
typedef struct CUevent_st* cudaEvent_t;
typedef struct CUfunc_st* CUfunction;
typedef struct CUmod_st* CUmodule;
typedef struct CUstream_st* cudaStream_t;
typedef struct CUgraph_st* cudaGraph_t;
typedef struct CUgraphExec_st* cudaGraphExec_t;
typedef struct CUlinkState_st* CUlinkState;
typedef struct CUarray_st* CUarray;
struct CUDA_ARRAY_DESCRIPTOR {
    CUarray_format Format;
    size_t Height;
    unsigned int NumChannels;
    size_t Width;
};


///////////////////////////////////////////////////////////////////////////////
// cuda_runtime.h
///////////////////////////////////////////////////////////////////////////////

enum {
    cudaDevAttrComputeCapabilityMajor = 75,
    cudaDevAttrComputeCapabilityMinor = 76,
};

typedef enum {
    cudaSuccess = 0,
    cudaErrorInvalidValue = 1,
    cudaErrorMemoryAllocation = 2,
    cudaErrorInvalidResourceHandle = 400,
    cudaErrorContextIsDestroyed = 709,
    cudaErrorPeerAccessAlreadyEnabled = 704,
} cudaError_t;
typedef enum {} cudaDataType;
enum cudaDeviceAttr {};
enum cudaLimit {};
enum cudaMemoryAdvise {};
enum cudaMemcpyKind {};


typedef void (*cudaStreamCallback_t)(
    cudaStream_t stream, cudaError_t status, void* userData);

typedef void (*cudaHostFn_t)(void* userData);

struct cudaPointerAttributes{
    int device;
    void* devicePointer;
    void* hostPointer;
};


enum cudaChannelFormatKind {};
typedef unsigned long long cudaTextureObject_t;
typedef unsigned long long cudaSurfaceObject_t;
enum cudaResourceType {};
enum cudaTextureAddressMode {};
enum cudaTextureFilterMode {};
enum cudaTextureReadMode {};
struct cudaResourceViewDesc;
typedef void* cudaArray_t;
struct cudaExtent {
    size_t width, height, depth;
};
struct cudaPos {
    size_t x, y, z;
};
struct cudaPitchedPtr {
    size_t pitch;
    void* ptr;
    size_t xsize, ysize;
};
typedef void* cudaMipmappedArray_t;
struct cudaMemcpy3DParms {
    cudaArray_t srcArray;
    struct cudaPos srcPos;
    struct cudaPitchedPtr srcPtr;
    cudaArray_t dstArray;
    struct cudaPos dstPos;
    struct cudaPitchedPtr dstPtr;
    struct cudaExtent extent;
    enum cudaMemcpyKind kind;
};
struct cudaChannelFormatDesc {
    int x, y, z, w;
    enum cudaChannelFormatKind f;
};
struct cudaResourceDesc {
    enum cudaResourceType resType;

    union {
        struct {
            cudaArray_t array;
        } array;
        struct {
            cudaMipmappedArray_t mipmap;
        } mipmap;
        struct {
            void *devPtr;
            struct cudaChannelFormatDesc desc;
            size_t sizeInBytes;
        } linear;
        struct {
            void *devPtr;
            struct cudaChannelFormatDesc desc;
            size_t width;
            size_t height;
            size_t pitchInBytes;
        } pitch2D;
    } res;
};
struct cudaTextureDesc {
    enum cudaTextureAddressMode addressMode[3];
    enum cudaTextureFilterMode filterMode;
    enum cudaTextureReadMode readMode;
    int sRGB;
    float borderColor[4];
    int normalizedCoords;
    unsigned int maxAnisotropy;
    enum cudaTextureFilterMode mipmapFilterMode;
    float mipmapLevelBias;
    float minMipmapLevelClamp;
    float maxMipmapLevelClamp;
};

// IPC operations
typedef struct {
    unsigned char reserved[64];
} cudaIpcMemHandle_t;

// IPC operations
typedef struct {
    unsigned char reserved[64];
} cudaIpcEventHandle_t;

typedef struct {
     char name[256];
     size_t totalGlobalMem;
     size_t sharedMemPerBlock;
     int regsPerBlock;
     int warpSize;
     int maxThreadsPerBlock;
     int maxThreadsDim[3];
     int maxGridSize[3];
     int clockRate;
     int memoryClockRate;
     int memoryBusWidth;
     size_t totalConstMem;
     int major;
     int minor;
     int multiProcessorCount;
     int l2CacheSize;
     int maxThreadsPerMultiProcessor;
     int computeMode;
     int clockInstructionRate;
     int concurrentKernels;
     int pciBusID;
     int pciDeviceID;
     size_t maxSharedMemoryPerMultiProcessor;
     int isMultiGpuBoard;
     int canMapHostMemory;
} cudaDeviceProp;

typedef void* cudaMemPool_t;
enum cudaMemPoolAttr {};


///////////////////////////////////////////////////////////////////////////////
// library_types.h
///////////////////////////////////////////////////////////////////////////////

typedef enum libraryPropertyType_t {
	MAJOR_VERSION,
	MINOR_VERSION,
	PATCH_LEVEL
} libraryPropertyType;


///////////////////////////////////////////////////////////////////////////////
// cublas_v2.h
///////////////////////////////////////////////////////////////////////////////

typedef void* cublasHandle_t;

typedef enum {} cublasDiagType_t;
typedef enum {} cublasFillMode_t;
typedef enum {} cublasOperation_t;
typedef enum {} cublasPointerMode_t;
typedef enum {} cublasSideMode_t;
typedef enum {} cublasGemmAlgo_t;
typedef enum {} cublasMath_t;
typedef enum {
    CUBLAS_STATUS_SUCCESS=0,
} cublasStatus_t;

} // extern "C"

#endif // #ifndef INCLUDE_GUARD_STUB_CUPY_CUDA_COMMON_H