hip_runtime_api.h

/*
Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved.

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 HIP_INCLUDE_HIP_HIP_RUNTIME_API_H
#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H


#include <string.h>  // for getDeviceProp
#include <hip/hip_version.h>
#include <hip/hip_common.h>

enum {
    HIP_SUCCESS = 0,
    HIP_ERROR_INVALID_VALUE,
    HIP_ERROR_NOT_INITIALIZED,
    HIP_ERROR_LAUNCH_OUT_OF_RESOURCES
};

typedef struct {
    // 32-bit Atomics
    unsigned hasGlobalInt32Atomics : 1;     
    unsigned hasGlobalFloatAtomicExch : 1;  
    unsigned hasSharedInt32Atomics : 1;     
    unsigned hasSharedFloatAtomicExch : 1;  
    unsigned hasFloatAtomicAdd : 1;  

    // 64-bit Atomics
    unsigned hasGlobalInt64Atomics : 1;  
    unsigned hasSharedInt64Atomics : 1;  

    // Doubles
    unsigned hasDoubles : 1;  

    // Warp cross-lane operations
    unsigned hasWarpVote : 1;     
    unsigned hasWarpBallot : 1;   
    unsigned hasWarpShuffle : 1;  
    unsigned hasFunnelShift : 1;  

    // Sync
    unsigned hasThreadFenceSystem : 1;  
    unsigned hasSyncThreadsExt : 1;     

    // Misc
    unsigned hasSurfaceFuncs : 1;        
    unsigned has3dGrid : 1;              
    unsigned hasDynamicParallelism : 1;  
} hipDeviceArch_t;


//---
// Common headers for both NVCC and HCC paths:

typedef struct hipDeviceProp_t {
    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;  
    hipDeviceArch_t arch;      
    int concurrentKernels;     
    int pciDomainID;           
    int pciBusID;              
    int pciDeviceID;           
    size_t maxSharedMemoryPerMultiProcessor;  
    int isMultiGpuBoard;                      
    int canMapHostMemory;                     
    int gcnArch;                              
    char gcnArchName[256];                    
    int integrated;            
    int cooperativeLaunch;            
    int cooperativeMultiDeviceLaunch; 
    int maxTexture1DLinear;    
    int maxTexture1D;          
    int maxTexture2D[2];       
    int maxTexture3D[3];       
    unsigned int* hdpMemFlushCntl;      
    unsigned int* hdpRegFlushCntl;      
    size_t memPitch;                 
    size_t textureAlignment;         
    size_t texturePitchAlignment;    
    int kernelExecTimeoutEnabled;    
    int ECCEnabled;                  
    int tccDriver;                   
    int cooperativeMultiDeviceUnmatchedFunc;        
    int cooperativeMultiDeviceUnmatchedGridDim;     
    int cooperativeMultiDeviceUnmatchedBlockDim;    
    int cooperativeMultiDeviceUnmatchedSharedMem;   
    int isLargeBar;                  
    int asicRevision;                
    int managedMemory;               
    int directManagedMemAccessFromHost; 
    int concurrentManagedAccess;     
    int pageableMemoryAccess;        
    int pageableMemoryAccessUsesHostPageTables; 
} hipDeviceProp_t;


typedef enum hipMemoryType {
    hipMemoryTypeHost,    
    hipMemoryTypeDevice,  
    hipMemoryTypeArray,  
    hipMemoryTypeUnified  
}hipMemoryType;


typedef struct hipPointerAttribute_t {
    enum hipMemoryType memoryType;
    int device;
    void* devicePointer;
    void* hostPointer;
    int isManaged;
    unsigned allocationFlags; /* flags specified when memory was allocated*/
    /* peers? */
} hipPointerAttribute_t;


// hack to get these to show up in Doxygen:
// Ignoring error-code return values from hip APIs is discouraged. On C++17,
// we can make that yield a warning
#if __cplusplus >= 201703L
#define __HIP_NODISCARD [[nodiscard]]
#else
#define __HIP_NODISCARD
#endif

/*
 * @brief hipError_t
 * @enum
 * @ingroup Enumerations
 */
// Developer note - when updating these, update the hipErrorName and hipErrorString functions in
// NVCC and HCC paths Also update the hipCUDAErrorTohipError function in NVCC path.

typedef enum __HIP_NODISCARD hipError_t {
    hipSuccess = 0,  
    hipErrorInvalidValue = 1,  
    hipErrorOutOfMemory = 2,
    // Deprecated
    hipErrorMemoryAllocation = 2,  
    hipErrorNotInitialized = 3,
    // Deprecated
    hipErrorInitializationError = 3,
    hipErrorDeinitialized = 4,
    hipErrorProfilerDisabled = 5,
    hipErrorProfilerNotInitialized = 6,
    hipErrorProfilerAlreadyStarted = 7,
    hipErrorProfilerAlreadyStopped = 8,
    hipErrorInvalidConfiguration = 9,
    hipErrorInvalidSymbol = 13,
    hipErrorInvalidDevicePointer = 17,  
    hipErrorInvalidMemcpyDirection = 21,  
    hipErrorInsufficientDriver = 35,
    hipErrorMissingConfiguration = 52,
    hipErrorPriorLaunchFailure = 53,
    hipErrorInvalidDeviceFunction = 98,
    hipErrorNoDevice = 100,  
    hipErrorInvalidDevice = 101,  
    hipErrorInvalidImage = 200,
    hipErrorInvalidContext = 201,  
    hipErrorContextAlreadyCurrent = 202,
    hipErrorMapFailed = 205,
    // Deprecated
    hipErrorMapBufferObjectFailed = 205,  
    hipErrorUnmapFailed = 206,
    hipErrorArrayIsMapped = 207,
    hipErrorAlreadyMapped = 208,
    hipErrorNoBinaryForGpu = 209,
    hipErrorAlreadyAcquired = 210,
    hipErrorNotMapped = 211,
    hipErrorNotMappedAsArray = 212,
    hipErrorNotMappedAsPointer = 213,
    hipErrorECCNotCorrectable = 214,
    hipErrorUnsupportedLimit = 215,
    hipErrorContextAlreadyInUse = 216,
    hipErrorPeerAccessUnsupported = 217,
    hipErrorInvalidKernelFile = 218,  
    hipErrorInvalidGraphicsContext = 219,
    hipErrorInvalidSource = 300,
    hipErrorFileNotFound = 301,
    hipErrorSharedObjectSymbolNotFound = 302,
    hipErrorSharedObjectInitFailed = 303,
    hipErrorOperatingSystem = 304,
    hipErrorInvalidHandle = 400,
    // Deprecated
    hipErrorInvalidResourceHandle = 400,  
    hipErrorNotFound = 500,
    hipErrorNotReady = 600,  
    hipErrorIllegalAddress = 700,
    hipErrorLaunchOutOfResources = 701,  
    hipErrorLaunchTimeOut = 702,
    hipErrorPeerAccessAlreadyEnabled =
        704,  
    hipErrorPeerAccessNotEnabled =
        705,  
    hipErrorSetOnActiveProcess = 708,
    hipErrorAssert = 710,  
    hipErrorHostMemoryAlreadyRegistered =
        712,  
    hipErrorHostMemoryNotRegistered =
        713,  
    hipErrorLaunchFailure =
        719,  
    hipErrorCooperativeLaunchTooLarge =
        720,  
    hipErrorNotSupported = 801,  
    hipErrorUnknown = 999,  //< Unknown error.
    // HSA Runtime Error Codes start here.
    hipErrorRuntimeMemory = 1052,  
    hipErrorRuntimeOther = 1053,  
    hipErrorTbd  
} hipError_t;

#undef __HIP_NODISCARD

/*
 * @brief hipDeviceAttribute_t
 * @enum
 * @ingroup Enumerations
 */
typedef enum hipDeviceAttribute_t {
    hipDeviceAttributeMaxThreadsPerBlock,       
    hipDeviceAttributeMaxBlockDimX,             
    hipDeviceAttributeMaxBlockDimY,             
    hipDeviceAttributeMaxBlockDimZ,             
    hipDeviceAttributeMaxGridDimX,              
    hipDeviceAttributeMaxGridDimY,              
    hipDeviceAttributeMaxGridDimZ,              
    hipDeviceAttributeMaxSharedMemoryPerBlock,  
    hipDeviceAttributeTotalConstantMemory,      
    hipDeviceAttributeWarpSize,                 
    hipDeviceAttributeMaxRegistersPerBlock,  
    hipDeviceAttributeClockRate,             
    hipDeviceAttributeMemoryClockRate,       
    hipDeviceAttributeMemoryBusWidth,        
    hipDeviceAttributeMultiprocessorCount,   
    hipDeviceAttributeComputeMode,           
    hipDeviceAttributeL2CacheSize,  
    hipDeviceAttributeMaxThreadsPerMultiProcessor,  
    hipDeviceAttributeComputeCapabilityMajor,       
    hipDeviceAttributeComputeCapabilityMinor,       
    hipDeviceAttributeConcurrentKernels,  
    hipDeviceAttributePciBusId,           
    hipDeviceAttributePciDeviceId,        
    hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,  
    hipDeviceAttributeIsMultiGpuBoard,                   
    hipDeviceAttributeIntegrated,                        
    hipDeviceAttributeCooperativeLaunch,                 
    hipDeviceAttributeCooperativeMultiDeviceLaunch,      
    hipDeviceAttributeMaxTexture1DWidth,    
    hipDeviceAttributeMaxTexture2DWidth,    
    hipDeviceAttributeMaxTexture2DHeight,   
    hipDeviceAttributeMaxTexture3DWidth,    
    hipDeviceAttributeMaxTexture3DHeight,   
    hipDeviceAttributeMaxTexture3DDepth,    

    hipDeviceAttributeHdpMemFlushCntl,      
    hipDeviceAttributeHdpRegFlushCntl,      

    hipDeviceAttributeMaxPitch,             
    hipDeviceAttributeTextureAlignment,     
    hipDeviceAttributeTexturePitchAlignment, 
    hipDeviceAttributeKernelExecTimeout,    
    hipDeviceAttributeCanMapHostMemory,     
    hipDeviceAttributeEccEnabled,           

    hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,        
    hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,     
    hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,    
    hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,   
    hipDeviceAttributeAsicRevision,         
    hipDeviceAttributeManagedMemory,        
    hipDeviceAttributeDirectManagedMemAccessFromHost, 
    hipDeviceAttributeConcurrentManagedAccess,  
    hipDeviceAttributePageableMemoryAccess,     
    hipDeviceAttributePageableMemoryAccessUsesHostPageTables, 
} hipDeviceAttribute_t;

enum hipComputeMode {
    hipComputeModeDefault = 0,
    hipComputeModeExclusive = 1,
    hipComputeModeProhibited = 2,
    hipComputeModeExclusiveProcess = 3
};

#if defined(__HIP_PLATFORM_HCC__) && !defined(__HIP_PLATFORM_NVCC__)
#include "hip/hcc_detail/hip_runtime_api.h"
#elif defined(__HIP_PLATFORM_NVCC__) && !defined(__HIP_PLATFORM_HCC__)
#include "hip/nvcc_detail/hip_runtime_api.h"
#else
#error("Must define exactly one of __HIP_PLATFORM_HCC__ or __HIP_PLATFORM_NVCC__");
#endif


#if defined(__cplusplus) && !defined(__HIP_DISABLE_CPP_FUNCTIONS__)
template <class T>
static inline hipError_t hipMalloc(T** devPtr, size_t size) {
    return hipMalloc((void**)devPtr, size);
}

// Provide an override to automatically typecast the pointer type from void**, and also provide a
// default for the flags.
template <class T>
static inline hipError_t hipHostMalloc(T** ptr, size_t size,
                                       unsigned int flags = hipHostMallocDefault) {
    return hipHostMalloc((void**)ptr, size, flags);
}

template <class T>
static inline hipError_t hipMallocManaged(T** devPtr, size_t size,
                                       unsigned int flags = hipMemAttachGlobal) {
    return hipMallocManaged((void**)devPtr, size, flags);
}
#endif

#endif