diff --git a/src/CUDA2HIP.cpp b/src/CUDA2HIP.cpp index 67f7c84b..d374ec03 100644 --- a/src/CUDA2HIP.cpp +++ b/src/CUDA2HIP.cpp @@ -105,6 +105,7 @@ const std::map CUDA_INCLUDE_MAP { {"caffe2/core/common_cudnn.h", {"caffe2/core/hip/common_miopen.h", "", CONV_INCLUDE, API_CAFFE2, 0}}, // RTC includes {"nvrtc.h", {"hip/hiprtc.h", "", CONV_INCLUDE_CUDA_MAIN_H, API_RTC, 0}}, + {"cufile.h", {"hipfile.h", "", CONV_INCLUDE, API_FILE, 0}}, }; const std::map &CUDA_RENAMES_MAP() { @@ -140,6 +141,8 @@ const std::map &CUDA_RENAMES_MAP() { ret.insert(CUDA_SOLVER_FUNCTION_MAP.begin(), CUDA_SOLVER_FUNCTION_MAP.end()); ret.insert(CUDA_TENSOR_TYPE_NAME_MAP.begin(), CUDA_TENSOR_TYPE_NAME_MAP.end()); ret.insert(CUDA_TENSOR_FUNCTION_MAP.begin(), CUDA_TENSOR_FUNCTION_MAP.end()); + ret.insert(CUDA_FILE_TYPE_NAME_MAP.begin(), CUDA_FILE_TYPE_NAME_MAP.end()); + ret.insert(CUDA_FILE_FUNCTION_MAP.begin(), CUDA_FILE_FUNCTION_MAP.end()); return ret; }; @@ -185,6 +188,8 @@ const std::map &CUDA_VERSIONS_MAP() { ret.insert(CUDA_SOLVER_FUNCTION_VER_MAP.begin(), CUDA_SOLVER_FUNCTION_VER_MAP.end()); ret.insert(CUDA_TENSOR_TYPE_NAME_VER_MAP.begin(), CUDA_TENSOR_TYPE_NAME_VER_MAP.end()); ret.insert(CUDA_TENSOR_FUNCTION_VER_MAP.begin(), CUDA_TENSOR_FUNCTION_VER_MAP.end()); + ret.insert(CUDA_FILE_TYPE_NAME_VER_MAP.begin(), CUDA_FILE_TYPE_NAME_VER_MAP.end()); + ret.insert(CUDA_FILE_FUNCTION_VER_MAP.begin(), CUDA_FILE_FUNCTION_VER_MAP.end()); return ret; } @@ -221,5 +226,7 @@ const std::map &HIP_VERSIONS_MAP() { ret.insert(HIP_SOLVER_FUNCTION_VER_MAP.begin(), HIP_SOLVER_FUNCTION_VER_MAP.end()); ret.insert(HIP_TENSOR_TYPE_NAME_VER_MAP.begin(), HIP_TENSOR_TYPE_NAME_VER_MAP.end()); ret.insert(HIP_TENSOR_FUNCTION_VER_MAP.begin(), HIP_TENSOR_FUNCTION_VER_MAP.end()); + ret.insert(HIP_FILE_TYPE_NAME_VER_MAP.begin(), HIP_FILE_TYPE_NAME_VER_MAP.end()); + ret.insert(HIP_FILE_FUNCTION_VER_MAP.begin(), HIP_FILE_FUNCTION_VER_MAP.end()); return ret; } diff --git a/src/CUDA2HIP.h b/src/CUDA2HIP.h index 9ec88feb..8957603a 100644 --- a/src/CUDA2HIP.h +++ b/src/CUDA2HIP.h @@ -89,6 +89,10 @@ extern const std::map CUDA_SOLVER_FUNCTION_MAP; extern const std::map CUDA_TENSOR_TYPE_NAME_MAP; // Maps the names of CUDA TENSOR API functions to the corresponding HIP functions extern const std::map CUDA_TENSOR_FUNCTION_MAP; +// Maps the names of cuFile API types to the corresponding HIP types +extern const std::map CUDA_FILE_TYPE_NAME_MAP; +// Maps the names of cuFile API functions to the corresponding HIP types +extern const std::map CUDA_FILE_FUNCTION_MAP; /** * The union of all the above maps, except includes. @@ -128,6 +132,8 @@ extern const std::map CUDA_SOLVER_TYPE_NAME_VE extern const std::map CUDA_SOLVER_FUNCTION_VER_MAP; extern const std::map CUDA_TENSOR_TYPE_NAME_VER_MAP; extern const std::map CUDA_TENSOR_FUNCTION_VER_MAP; +extern const std::map CUDA_FILE_TYPE_NAME_VER_MAP; +extern const std::map CUDA_FILE_FUNCTION_VER_MAP; // The union of all the above maps. const std::map &CUDA_VERSIONS_MAP(); @@ -177,6 +183,10 @@ extern const std::map HIP_TENSOR_FUNCTION_VER_M extern const std::map HIP_TENSOR_FUNCTION_CHANGED_VER_MAP; extern const std::map CUDA_TENSOR_FUNCTION_CHANGED_VER_MAP; extern const std::map CUDA_TENSOR_TYPE_CHANGED_VER_MAP; +extern const std::map HIP_FILE_TYPE_NAME_VER_MAP; +extern const std::map HIP_FILE_FUNCTION_VER_MAP; +extern const std::map HIP_FILE_FUNCTION_CHANGED_VER_MAP; +extern const std::map CUDA_FILE_FUNCTION_CHANGED_VER_MAP; // The union of all the above maps. const std::map &HIP_VERSIONS_MAP(); @@ -194,6 +204,7 @@ extern const std::map CUDA_RTC_API_SECTION_MAP; extern const std::map CUDA_CUB_API_SECTION_MAP; extern const std::map CUDA_SOLVER_API_SECTION_MAP; extern const std::map CUDA_TENSOR_API_SECTION_MAP; +extern const std::map CUDA_FILE_API_SECTION_MAP; extern const std::map CUDA_DRIVER_FUNCTION_UNSUPPORTED_VER_MAP; extern const std::map CUDA_RUNTIME_FUNCTION_UNSUPPORTED_VER_MAP; diff --git a/src/CUDA2HIP_Doc.cpp b/src/CUDA2HIP_Doc.cpp index f572d74f..4503f738 100644 --- a/src/CUDA2HIP_Doc.cpp +++ b/src/CUDA2HIP_Doc.cpp @@ -125,6 +125,12 @@ namespace doc { const string sROCSPARSE_csv = sROCSPARSE + csv_ext; const string sCUSPARSE = "CUSPARSE"; + /* hipFile */ + const string sHIPFILE = "cuFile_API_supported_by_HIP"; + const string sHIPFILE_md = sHIPFILE + md_ext; + const string sHIPFILE_csv = sHIPFILE + csv_ext; + const string sCUFILE = "cuFile"; + const string sDEVICE = "CUDA_Device_API_supported_by_HIP"; const string sDEVICE_md = sDEVICE + md_ext; const string sDEVICE_csv = sDEVICE + csv_ext; @@ -860,7 +866,38 @@ namespace doc { } }; - class DEVICE : public DOC { + class HIPFILE: public DOC { + public: + HIPFILE(const string &outDir): DOC(outDir) { hasROC = true; } + virtual ~HIPFILE() {} + protected: + const string sMetaKeywords = "hipFile, cuFile"; + const string &getAdditionalMetaKeywords() const override { return sMetaKeywords; } + + const sectionMap &getSections() const override { return CUDA_FILE_API_SECTION_MAP; } + const functionMap &getFunctions() const override { return CUDA_FILE_FUNCTION_MAP; } + const typeMap &getTypes() const override { return CUDA_FILE_TYPE_NAME_MAP; } + const versionMap &getFunctionVersions() const override { return CUDA_FILE_FUNCTION_VER_MAP; } + const hipVersionMap &getHipFunctionVersions() const override { return HIP_FILE_FUNCTION_VER_MAP; } + const hipChangedVersionMap &getHipChangedFunctionVersions() const override { return HIP_FILE_FUNCTION_CHANGED_VER_MAP; } + const cudaChangedVersionMap &getCudaChangedFunctionVersions() const override { return CUDA_FILE_FUNCTION_CHANGED_VER_MAP; } + const versionMap &getTypeVersions() const override { return CUDA_FILE_TYPE_NAME_VER_MAP; } + const hipVersionMap &getHipTypeVersions() const override { return HIP_FILE_TYPE_NAME_VER_MAP; } + + const string &getName() const override { return sCUFILE; } + const string &getSecondAPI() const override { return sEmpty; } + const string &getJointAPI() const override { return sEmpty; } + const string &getFileName(docType format) const override { + switch (format) { + case none: + default: return sEmpty; + case md: return sHIPFILE_md; + case csv: return sHIPFILE_csv; + } + } + }; + + class DEVICE : public DOC { public: DEVICE(const string &outDir): DOC(outDir) {} virtual ~DEVICE() {} @@ -1028,6 +1065,8 @@ namespace doc { docs.addDoc(&fft); SPARSE sparse(sOut); docs.addDoc(&sparse); + HIPFILE hipfile(sOut); + docs.addDoc(&hipfile); DEVICE device(sOut); docs.addDoc(&device); RTC rtc(sOut); diff --git a/src/CUDA2HIP_FILE_API_functions.cpp b/src/CUDA2HIP_FILE_API_functions.cpp new file mode 100644 index 00000000..1921e0d2 --- /dev/null +++ b/src/CUDA2HIP_FILE_API_functions.cpp @@ -0,0 +1,175 @@ +#include "CUDA2HIP.h" + +/* clang-format off */ +const std::map CUDA_FILE_FUNCTION_MAP { + {"cufileop_status_error", {"hipFileOpStatusError", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileHandleRegister", {"hipFileHandleRegister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileHandleDeregister", {"hipFileHandleDeregister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBufRegister", {"hipFileBufRegister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBufDeregister", {"hipFileBufDeregister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileRead", {"hipFileRead", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileWrite", {"hipFileWrite", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverOpen", {"hipFileDriverOpen", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverClose", {"hipFileDriverClose", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverClose_v2", {"hipFileDriverClose", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileUseCount", {"hipFileUseCount", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverGetProperties", {"hipFileDriverGetProperties", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverSetPollMode", {"hipFileDriverSetPollMode", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverSetMaxDirectIOSize", {"hipFileDriverSetMaxDirectIOSize", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverSetMaxCacheSize", {"hipFileDriverSetMaxCacheSize", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileDriverSetMaxPinnedMemSize", {"hipFileDriverSetMaxPinnedMemSize", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileWriteAsync", {"hipFileWriteAsync", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileReadAsync", {"hipFileReadAsync", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileStreamRegister", {"hipFileStreamRegister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileStreamDeregister", {"hipFileStreamDeregister", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBatchIOSetUp", {"hipFileBatchIOSetUp", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBatchIOSubmit", {"hipFileBatchIOSubmit", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBatchIOGetStatus", {"hipFileBatchIOGetStatus", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBatchIOCancel", {"hipFileBatchIOCancel", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileBatchIODestroy", {"hipFileBatchIODestroy", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileGetParameterSizeT", {"hipFileGetParameterSizeT", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileGetParameterBool", {"hipFileGetParameterBool", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileGetParameterString", {"hipFileGetParameterString", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileSetParameterSizeT", {"hipFileSetParameterSizeT", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileSetParameterBool", {"hipFileSetParameterBool", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, + {"cuFileSetParameterString", {"hipFileSetParameterString", "", CONV_LIB_FUNC, API_FILE, 2, FULL}}, +}; +/* clang-format on */ + +const std::map HIP_FILE_FUNCTION_VER_MAP { + {"hipFileOpStatusError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleRegister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleDeregister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBufRegister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBufDeregister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileRead", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileWrite", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverOpen", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverClose", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileUseCount", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverGetProperties", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverSetPollMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverSetMaxDirectIOSize", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverSetMaxCacheSize", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverSetMaxPinnedMemSize", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileWriteAsync", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileReadAsync", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileStreamRegister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileStreamDeregister", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIOSetUp", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIOSubmit", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIOGetStatus", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIOCancel", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIODestroy", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGetParameterSizeT", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGetParameterBool", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGetParameterString", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSetParameterSizeT", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSetParameterBool", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSetParameterString", {HIP_7000, HIP_0, HIP_0}}, +}; + +const std::map CUDA_FILE_FUNCTION_VER_MAP { + {"cufileop_status_error", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileHandleRegister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileHandleDeregister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBufRegister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBufDeregister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileRead", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileWrite", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverOpen", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverClose", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverClose_v2", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileUseCount", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverGetProperties", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverSetPollMode", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverSetMaxDirectIOSize", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverSetMaxCacheSize", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileDriverSetMaxPinnedMemSize", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileWriteAsync", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileReadAsync", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileStreamRegister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileStreamDeregister", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBatchIOSetUp", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBatchIOSubmit", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBatchIOGetStatus", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBatchIOCancel", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileBatchIODestroy", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileGetParameterSizeT", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileGetParameterBool", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileGetParameterString", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileSetParameterSizeT", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileSetParameterBool", {CUDA_129, CUDA_0, CUDA_0}}, + {"cuFileSetParameterString", {CUDA_129, CUDA_0, CUDA_0}}, +}; + +const std::map CUDA_FILE_FUNCTION_CHANGED_VER_MAP { + {"cufileop_status_error", {CUDA_0}}, + {"cuFileHandleRegister", {CUDA_0}}, + {"cuFileHandleDeregister", {CUDA_0}}, + {"cuFileBufRegister", {CUDA_0}}, + {"cuFileBufDeregister", {CUDA_0}}, + {"cuFileRead", {CUDA_0}}, + {"cuFileWrite", {CUDA_0}}, + {"cuFileDriverOpen", {CUDA_0}}, + {"cuFileDriverClose", {CUDA_0}}, + {"cuFileDriverClose_v2", {CUDA_0}}, + {"cuFileUseCount", {CUDA_0}}, + {"cuFileDriverGetProperties", {CUDA_0}}, + {"cuFileDriverSetPollMode", {CUDA_0}}, + {"cuFileDriverSetMaxDirectIOSize", {CUDA_0}}, + {"cuFileDriverSetMaxCacheSize", {CUDA_0}}, + {"cuFileDriverSetMaxPinnedMemSize", {CUDA_0}}, + {"cuFileWriteAsync", {CUDA_0}}, + {"cuFileReadAsync", {CUDA_0}}, + {"cuFileStreamRegister", {CUDA_0}}, + {"cuFileStreamDeregister", {CUDA_0}}, + {"cuFileBatchIOSetUp", {CUDA_0}}, + {"cuFileBatchIOSubmit", {CUDA_0}}, + {"cuFileBatchIOGetStatus", {CUDA_0}}, + {"cuFileBatchIOCancel", {CUDA_0}}, + {"cuFileBatchIODestroy", {CUDA_0}}, + {"cuFileGetParameterSizeT", {CUDA_0}}, + {"cuFileGetParameterBool", {CUDA_0}}, + {"cuFileGetParameterString", {CUDA_0}}, + {"cuFileSetParameterSizeT", {CUDA_0}}, + {"cuFileSetParameterBool", {CUDA_0}}, + {"cuFileSetParameterString", {CUDA_0}}, +}; + +const std::map HIP_FILE_FUNCTION_CHANGED_VER_MAP { + {"hipFileHandleRegister", {HIP_7000}}, + {"hipFileHandleDeregister", {HIP_7000}}, + {"hipFileBufRegister", {HIP_7000}}, + {"hipFileBufDeregister", {HIP_7000}}, + {"hipFileRead", {HIP_7000}}, + {"hipFileWrite", {HIP_7000}}, + {"hipFileDriverOpen", {HIP_7000}}, + {"hipFileDriverClose", {HIP_7000}}, + {"hipFileUseCount", {HIP_7000}}, + {"hipFileDriverGetProperties", {HIP_7000}}, + {"hipFileDriverSetPollMode", {HIP_7000}}, + {"hipFileDriverSetMaxDirectIOSize", {HIP_7000}}, + {"hipFileDriverSetMaxCacheSize", {HIP_7000}}, + {"hipFileDriverSetMaxPinnedMemSize", {HIP_7000}}, + {"hipFileWriteAsync", {HIP_7000}}, + {"hipFileReadAsync", {HIP_7000}}, + {"hipFileStreamRegister", {HIP_7000}}, + {"hipFileStreamDeregister", {HIP_7000}}, + {"hipFileBatchIOSetUp", {HIP_7000}}, + {"hipFileBatchIOSubmit", {HIP_7000}}, + {"hipFileBatchIOGetStatus", {HIP_7000}}, + {"hipFileBatchIOCancel", {HIP_7000}}, + {"hipFileBatchIODestroy", {HIP_7000}}, + {"hipFileGetParameterSizeT", {HIP_7000}}, + {"hipFileGetParameterBool", {HIP_7000}}, + {"hipFileGetParameterString", {HIP_7000}}, + {"hipFileSetParameterSizeT", {HIP_7000}}, + {"hipFileSetParameterBool", {HIP_7000}}, + {"hipFileSetParameterString", {HIP_7000}}, +}; + +const std::map CUDA_FILE_API_SECTION_MAP { + {1, "cuFile Types"}, + {2, "cuFile Functions"}, +}; diff --git a/src/CUDA2HIP_FILE_API_types.cpp b/src/CUDA2HIP_FILE_API_types.cpp new file mode 100644 index 00000000..2954d0e8 --- /dev/null +++ b/src/CUDA2HIP_FILE_API_types.cpp @@ -0,0 +1,396 @@ +#include "CUDA2HIP.h" + +const std::map CUDA_FILE_TYPE_NAME_MAP { + {"CUfileOpError", {"hipFileOpError_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileError_t", {"hipFileError_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileDriverStatusFlags_t", {"hipFileDriverStatusFlags_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileDriverControlFlags_t", {"hipFileDriverControlFlags_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileFeatureFlags_t", {"hipFileFeatureFlags_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileFileHandleType", {"hipFileFileHandleType", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileDrvProps_t", {"hipFileDriverProps_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"cufileRDMAInfo_t", {"hipFileRDMAInfo_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileFSOps_t", {"hipFileFSOps_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileDescr_t", {"hipFileDescr_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileHandle_t", {"hipFileHandle_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileIOParams_t", {"hipFileIOParams_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileIOEvents_t", {"hipFileIOEvents_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileOpcode_t", {"hipFileOpcode_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileStatus_t", {"hipFileStatus_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileBatchHandle_t", {"hipFileBatchHandle_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUfileBatchMode_t", {"hipFileBatchMode_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUFileSizeTConfigParameter_t", {"hipFileSizeTConfigParameter_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUFileBoolConfigParameter_t", {"hipFileBoolConfigParameter_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CUFileStringConfigParameter_t", {"hipFileStringConfigParameter_t", "", CONV_TYPE, API_FILE, 1, FULL}}, + {"CU_FILE_SUCCESS", {"hipFileSuccess", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_NOT_INITIALIZED", {"hipFileDriverNotInitialized", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_INVALID_PROPS", {"hipFileDriverInvalidProps", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_UNSUPPORTED_LIMIT", {"hipFileDriverUnsupportedLimit", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_VERSION_MISMATCH", {"hipFileDriverVersionMismatch", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_VERSION_READ_ERROR", {"hipFileDriverVersionReadError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_CLOSING", {"hipFileDriverClosing", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_PLATFORM_NOT_SUPPORTED", {"hipFilePlatformNotSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_IO_NOT_SUPPORTED", {"hipFileIONotSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DEVICE_NOT_SUPPORTED", {"hipFileDeviceNotSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVFS_DRIVER_ERROR", {"hipFileDriverError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_CUDA_DRIVER_ERROR", {"hipFileHipDriverError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_CUDA_POINTER_INVALID", {"hipFileHipPointerInvalid", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_CUDA_MEMORY_TYPE_INVALID", {"hipFileHipMemoryTypeInvalid", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_CUDA_POINTER_RANGE_ERROR", {"hipFileHipPointerRangeError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_CUDA_CONTEXT_MISMATCH", {"hipFileHipContextMismatch", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INVALID_MAPPING_SIZE", {"hipFileInvalidMappingSize", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INVALID_MAPPING_RANGE", {"hipFileInvalidMappingRange", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INVALID_FILE_TYPE", {"hipFileInvalidFileType", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INVALID_FILE_OPEN_FLAG", {"hipFileInvalidFileOpenFlag", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DIO_NOT_SET", {"hipFileDIONotSet", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INVALID_VALUE", {"hipFileInvalidValue", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_MEMORY_ALREADY_REGISTERED", {"hipFileMemoryAlreadyRegistered", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_MEMORY_NOT_REGISTERED", {"hipFileMemoryNotRegistered", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_PERMISSION_DENIED", {"hipFilePermissionDenied", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DRIVER_ALREADY_OPEN", {"hipFileDriverAlreadyOpen", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_HANDLE_NOT_REGISTERED", {"hipFileHandleNotRegistered", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_HANDLE_ALREADY_REGISTERED", {"hipFileHandleAlreadyRegistered", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DEVICE_NOT_FOUND", {"hipFileDeviceNotFound", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_INTERNAL_ERROR", {"hipFileInternalError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_GETNEWFD_FAILED", {"hipFileGetNewFDFailed", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVFS_SETUP_ERROR", {"hipFileDriverSetupError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_IO_DISABLED", {"hipFileIODisabled", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_BATCH_SUBMIT_FAILED", {"hipFileBatchSubmitFailed", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_GPU_MEMORY_PINNING_FAILED", {"hipFileGPUMemoryPinningFailed", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_BATCH_FULL", {"hipFileBatchFull", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_ASYNC_NOT_SUPPORTED", {"hipFileAsyncNotSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_IO_MAX_ERROR", {"hipFileIOMaxError", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_LUSTRE_SUPPORTED", {"hipFileLustreSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_WEKAFS_SUPPORTED", {"hipFileWekaFSSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NFS_SUPPORTED", {"hipFileNFSSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_GPFS_SUPPORTED", {"hipFileGPFSSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVME_SUPPORTED", {"hipFileNVMeSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVMEOF_SUPPORTED", {"hipFileNVMeoFSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_SCSI_SUPPORTED", {"hipFileSCSISupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_SCALEFLUX_CSD_SUPPORTED", {"hipFileScaleFluxCSDSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVMESH_SUPPORTED", {"hipFileNVMeshSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_BEEGFS_SUPPORTED", {"hipFileBEEGFSSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_NVME_P2P_SUPPORTED", {"hipFileNVMeP2PSsupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_USE_POLL_MODE", {"hipFileUsePollMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_ALLOW_COMPAT_MODE", {"hipFileAllowCompatMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_DYN_ROUTING_SUPPORTED", {"hipFileDynRoutingSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_BATCH_IO_SUPPORTED", {"hipFileBatchIOSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_STREAMS_SUPPORTED", {"hipFileStreamsSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_PARALLEL_IO_SUPPORTED", {"hipFileParallelIOSupported", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_RDMA_REGISTER", {"HIPFILE_RDMA_REGISTER", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_RDMA_RELAXED_ORDERING", {"HIPFILE_RDMA_RELAXED_ORDERING", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_HANDLE_TYPE_OPAQUE_FD", {"hipFileHandleTypeOpaqueFD", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_HANDLE_TYPE_OPAQUE_WIN32", {"hipFileHandleTypeOpaqueWin32", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_HANDLE_TYPE_USERSPACE_FS", {"hipFileHandleTypeUserspaceFS", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_READ", {"hipFileBatchRead", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_WRITE", {"hipFileBatchWrite", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_WAITING", {"hipFileWaiting", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PENDING", {"hipFilePending", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_INVALID", {"hipFileInvalid", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_CANCELED", {"hipFileCanceled", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_COMPLETE", {"hipFileComplete", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_TIMEOUT", {"hipFileTimeout", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_FAILED", {"hipFileFailed", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_BATCH", {"hipFileBatch", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_STREAM_FIXED_BUF_OFFSET", {"HIPFILE_STREAM_FIXED_BUF_OFFSET", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_STREAM_FIXED_FILE_OFFSET", {"HIPFILE_STREAM_FIXED_FILE_OFFSET", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_STREAM_FIXED_FILE_SIZE", {"HIPFILE_STREAM_FIXED_FILE_SIZE", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CU_FILE_STREAM_PAGE_ALIGNED_INPUTS", {"HIPFILE_STREAM_PAGE_ALIGNED_INPUTS", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROFILE_STATS", {"hipFileParamProfileStats", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH", {"hipFileParamExecutionMaxIOQueueDepth", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_EXECUTION_MAX_IO_THREADS", {"hipFileParamExecutionMaxIOThreads", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB", {"hipFileParamExecutionMinIOThresholdSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM", {"hipFileParamExecutionMaxRequestParallelism", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB", {"hipFileParamPropertiesMaxDirectIOSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB", {"hipFileParamPropertiesMaxDeviceCacheSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB", {"hipFileParamPropertiesPerBufferCacheSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB", {"hipFileParamPropertiesMaxDevicePinnedMemSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE", {"hipFileParamPropertiesIOBatchsize", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB", {"hipFileParamPollthresholdSizeKB", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS", {"hipFileParamPropertiesBatchIOTimeoutMs", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_USE_POLL_MODE", {"hipFileParamPropertiesUsePollMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE", {"hipFileParamPropertiesAllowCompatMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_FORCE_COMPAT_MODE", {"hipFileParamForceCompatMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE", {"hipFileParamFsMiscApiCheckAggressive", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_EXECUTION_PARALLEL_IO", {"hipFileParamExecutionParallelIO", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROFILE_NVTX", {"hipFileParamProfileNvtx", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY", {"hipFileParamPropertiesAllowSystemMemory", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_USE_PCIP2PDMA", {"hipFileParamUsePcip2pdma", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_PREFER_IO_URING", {"hipFileParamPreferIOUring", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_FORCE_ODIRECT_MODE", {"hipFileParamForceOdirectMode", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION", {"hipFileParamSkipTopologyDetection", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_STREAM_MEMOPS_BYPASS", {"hipFileParamStreamMemopsBypass", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_LOGGING_LEVEL", {"hipFileParamLoggingLevel", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_ENV_LOGFILE_PATH", {"hipFileParamEnvLogfilePath", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"CUFILE_PARAM_LOG_DIR", {"hipFileParamLogDir", "", CONV_NUMERIC_LITERAL, API_FILE, 1, FULL}}, + {"IS_CUFILE_ERR", {"IS_HIPFILE_ERR", "", CONV_DEFINE, API_FILE, 1, FULL}}, + {"CUFILE_ERRSTR", {"HIPFILE_ERRSTR", "", CONV_DEFINE, API_FILE, 1, FULL}}, + {"CUDA_DRV_ERR", {"HIP_DRV_ERR", "", CONV_DEFINE, API_FILE, 1, FULL}}, + {"IS_CUDA_ERR", {"IS_HIP_DRV_ERR", "", CONV_DEFINE, API_FILE, 1, FULL}}, +}; + +// struct cudaAPIversions { +// cudaVersions appeared; +// cudaVersions deprecated; +// cudaVersions removed; +// }; + +const std::map CUDA_FILE_TYPE_NAME_VER_MAP { + {"CUfileOpError", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileError_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileDriverStatusFlags_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileDriverControlFlags_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileFeatureFlags_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileFileHandleType", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileDrvProps_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"cufileRDMAInfo_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"cufileFSOps_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileDescr_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileHandle_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileIOParams_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileIOEvents_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileBatchHandle_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUfileBatchMode_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFileSizeTConfigParameter_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFileBoolConfigParameter_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFileStringConfigParameter_t", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_SUCCESS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_NOT_INITIALIZED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_INVALID_PROPS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_UNSUPPORTED_LIMIT", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_VERSION_MISMATCH", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_VERSION_READ_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_CLOSING", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_PLATFORM_NOT_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_IO_NOT_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DEVICE_NOT_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVFS_DRIVER_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_CUDA_DRIVER_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_CUDA_POINTER_INVALID", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_CUDA_MEMORY_TYPE_INVALID", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_CUDA_POINTER_RANGE_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_CUDA_CONTEXT_MISMATCH", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INVALID_MAPPING_SIZE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INVALID_MAPPING_RANGE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INVALID_FILE_TYPE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INVALID_FILE_OPEN_FLAG", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DIO_NOT_SET", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INVALID_VALUE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_MEMORY_ALREADY_REGISTERED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_MEMORY_NOT_REGISTERED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_PERMISSION_DENIED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DRIVER_ALREADY_OPEN", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_HANDLE_NOT_REGISTERED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_HANDLE_ALREADY_REGISTERED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DEVICE_NOT_FOUND", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_INTERNAL_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_GETNEWFD_FAILED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVFS_SETUP_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_IO_DISABLED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_BATCH_SUBMIT_FAILED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_GPU_MEMORY_PINNING_FAILED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_BATCH_FULL", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_ASYNC_NOT_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_IO_MAX_ERROR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_LUSTRE_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_WEKAFS_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NFS_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_GPFS_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVME_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVMEOF_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_SCSI_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_SCALEFLUX_CSD_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVMESH_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_BEEGFS_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_NVME_P2P_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_USE_POLL_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_ALLOW_COMPAT_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_DYN_ROUTING_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_BATCH_IO_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_STREAMS_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_PARALLEL_IO_SUPPORTED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_RDMA_REGISTER", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_RDMA_RELAXED_ORDERING", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_HANDLE_TYPE_OPAQUE_FD", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_HANDLE_TYPE_OPAQUE_WIN32", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_HANDLE_TYPE_USERSPACE_FS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_READ", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_WRITE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_WAITING", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PENDING", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_INVALID", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_CANCELED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_COMPLETE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_TIMEOUT", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_FAILED", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_BATCH", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_STREAM_FIXED_BUF_OFFSET", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_STREAM_FIXED_FILE_OFFSET", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_STREAM_FIXED_FILE_SIZE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CU_FILE_STREAM_PAGE_ALIGNED_INPUTS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROFILE_STATS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_EXECUTION_MAX_IO_THREADS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_USE_POLL_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_FORCE_COMPAT_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_EXECUTION_PARALLEL_IO", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROFILE_NVTX", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_USE_PCIP2PDMA", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_PREFER_IO_URING", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_FORCE_ODIRECT_MODE", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_STREAM_MEMOPS_BYPASS", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_LOGGING_LEVEL", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_ENV_LOGFILE_PATH", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_PARAM_LOG_DIR", {CUDA_129, CUDA_0, CUDA_0}}, + {"IS_CUFILE_ERR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUFILE_ERRSTR", {CUDA_129, CUDA_0, CUDA_0}}, + {"CUDA_DRV_ERR", {CUDA_129, CUDA_0, CUDA_0}}, + {"IS_CUDA_ERR", {CUDA_129, CUDA_0, CUDA_0}}, +}; + +// struct hipAPIversions { +// hipVersions appeared; +// hipVersions deprecated; +// hipVersions removed; +// hipVersions experimental = HIP_0; +// }; + +const std::map HIP_FILE_TYPE_NAME_VER_MAP { + {"hipFileOpError_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileError_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverStatusFlags_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverControlFlags_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileFeatureFlags_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileFileHandleType", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverProps_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileRDMAInfo_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileFSOps_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDescr_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandle_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileIOParams_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileIOEvents_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileOpcode_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileStatus_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchHandle_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchMode_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSizeTConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBoolConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileStringConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSuccess", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverNotInitialized", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverInvalidProps", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverUnsupportedLimit", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverVersionMismatch", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverVersionReadError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverClosing", {HIP_7000, HIP_0, HIP_0}}, + {"hipFilePlatformNotSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileIONotSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDeviceNotSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHipDriverError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHipPointerInvalid", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHipMemoryTypeInvalid", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHipPointerRangeError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHipContextMismatch", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalidMappingSize", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalidMappingRange", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalidFileType", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalidFileOpenFlag", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDIONotSet", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalidValue", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileMemoryAlreadyRegistered", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileMemoryNotRegistered", {HIP_7000, HIP_0, HIP_0}}, + {"hipFilePermissionDenied", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverAlreadyOpen", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleNotRegistered", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleAlreadyRegistered", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDeviceNotFound", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInternalError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGetNewFDFailed", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDriverSetupError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileIODisabled", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchSubmitFailed", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGPUMemoryPinningFailed", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchFull", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileAsyncNotSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileIOMaxError", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileLustreSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileWekaFSSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileNFSSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileGPFSSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileNVMeSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileNVMeoFSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileSCSISupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileScaleFluxCSDSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileNVMeshSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBEEGFSSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileNVMeP2PSsupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileUsePollMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileAllowCompatMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileDynRoutingSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchIOSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileStreamsSupported", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParallelIOSupported", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_RDMA_REGISTER", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_RDMA_RELAXED_ORDERING", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleTypeOpaqueFD", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleTypeOpaqueWin32", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileHandleTypeUserspaceFS", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchRead", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatchWrite", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileWaiting", {HIP_7000, HIP_0, HIP_0}}, + {"hipFilePending", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileInvalid", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileCanceled", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileComplete", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileTimeout", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileFailed", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileBatch", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_STREAM_FIXED_BUF_OFFSET", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_STREAM_FIXED_FILE_OFFSET", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_STREAM_FIXED_FILE_SIZE", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_STREAM_PAGE_ALIGNED_INPUTS", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamProfileStats", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamExecutionMaxIOQueueDepth", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamExecutionMaxIOThreads", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamExecutionMinIOThresholdSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamExecutionMaxRequestParallelism", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesMaxDirectIOSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesMaxDeviceCacheSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesPerBufferCacheSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesMaxDevicePinnedMemSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesIOBatchsize", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPollthresholdSizeKB", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesBatchIOTimeoutMs", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesUsePollMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesAllowCompatMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamForceCompatMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamFsMiscApiCheckAggressive", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamExecutionParallelIO", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamProfileNvtx", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPropertiesAllowSystemMemory", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamUsePcip2pdma", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamPreferIOUring", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamForceOdirectMode", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamSkipTopologyDetection", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamStreamMemopsBypass", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamLoggingLevel", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamEnvLogfilePath", {HIP_7000, HIP_0, HIP_0}}, + {"hipFileParamLogDir", {HIP_7000, HIP_0, HIP_0}}, + {"IS_HIPFILE_ERR", {HIP_7000, HIP_0, HIP_0}}, + {"HIPFILE_ERRSTR", {HIP_7000, HIP_0, HIP_0}}, + {"HIP_DRV_ERR", {HIP_7000, HIP_0, HIP_0}}, + {"IS_HIP_DRV_ERR", {HIP_7000, HIP_0, HIP_0}}, +}; diff --git a/src/HipifyAction.cpp b/src/HipifyAction.cpp index 968cf8a3..767dbbb1 100644 --- a/src/HipifyAction.cpp +++ b/src/HipifyAction.cpp @@ -2452,6 +2452,10 @@ bool HipifyAction::Exclude(const hipCounter &hipToken) { if (insertedSOLVERHeader) return true; insertedSOLVERHeader = true; return false; + case API_FILE: + if (insertedFILEHeader) return true; + insertedFILEHeader = true; + return false; default: return false; } diff --git a/src/HipifyAction.h b/src/HipifyAction.h index a88dd813..37fabfa5 100644 --- a/src/HipifyAction.h +++ b/src/HipifyAction.h @@ -62,6 +62,7 @@ class HipifyAction : public clang::ASTFrontendAction, bool insertedSPARSEHeader_V2 = false; bool insertedComplexHeader = false; bool insertedSOLVERHeader = false; + bool insertedFILEHeader = false; bool firstHeader = false; bool pragmaOnce = false; clang::SourceLocation firstHeaderLoc; diff --git a/src/Statistics.cpp b/src/Statistics.cpp index 7a913d20..d93db2d0 100644 --- a/src/Statistics.cpp +++ b/src/Statistics.cpp @@ -150,7 +150,8 @@ const char *apiNames[NUM_API_TYPES] = { "CUB API", "CAFFE2 API", "RTC API", - "TENSOR API" + "TENSOR API", + "cuFile API", }; const char *apiTypes[NUM_API_TYPES] = { @@ -166,7 +167,8 @@ const char *apiTypes[NUM_API_TYPES] = { "API_SOLVER", "API_CAFFE2", "API_RTC", - "API_TENSOR" + "API_TENSOR", + "API_FILE" }; namespace { @@ -372,8 +374,8 @@ void Statistics::setActive(const std::string &name) { bool Statistics::isToRoc(const hipCounter &counter) { return ((counter.apiType == API_BLAS || counter.apiType == API_DNN || counter.apiType == API_SPARSE || counter.apiType == API_SOLVER || - counter.apiType == API_RUNTIME || counter.apiType == API_COMPLEX || counter.apiType == API_RAND) && TranslateToRoc) || - isToMIOpen(counter); + counter.apiType == API_RUNTIME || counter.apiType == API_COMPLEX || counter.apiType == API_RAND || counter.apiType == API_FILE) + && TranslateToRoc) || isToMIOpen(counter); } bool Statistics::isToMIOpen(const hipCounter &counter) { diff --git a/src/Statistics.h b/src/Statistics.h index 2f10906d..878e037a 100644 --- a/src/Statistics.h +++ b/src/Statistics.h @@ -188,6 +188,7 @@ enum ApiTypes { API_CAFFE2, API_RTC, API_TENSOR, + API_FILE, API_LAST }; constexpr int NUM_API_TYPES = (int) ApiTypes::API_LAST;