From fcf4543898add81b87286bea142acaea0207799d Mon Sep 17 00:00:00 2001 From: Dana Robinson Date: Thu, 13 Nov 2025 17:48:31 -0700 Subject: [PATCH] Remove the hipify patch We now direct people to the hipFile branch of our fork of ROCm/HIPIFY. --- hipfile/docs/introduction.rst | 7 - hipfile/hipify/README.md | 22 - hipfile/hipify/hipfile_hipify.diff | 1051 ---------------------------- 3 files changed, 1080 deletions(-) delete mode 100644 hipfile/hipify/README.md delete mode 100644 hipfile/hipify/hipfile_hipify.diff diff --git a/hipfile/docs/introduction.rst b/hipfile/docs/introduction.rst index 1cdcbdc4..e4efdd86 100644 --- a/hipfile/docs/introduction.rst +++ b/hipfile/docs/introduction.rst @@ -9,10 +9,3 @@ were set when building the library, respectively. The documentation for hipFile is somewhat sparse as it's a very thin layer. For API details, see AMD's rocFile or NVIDIA's cuFile API documentation. - -Modifying CUDA code for hipFile -------------------------------- -Until the hipify tool has been updated to handle hipFile, the distribution -will contain a source patch to hipify that can be used to transform cuFile -code to the hipFile API. Please see the `README.md` included with the patch -for instructions. diff --git a/hipfile/hipify/README.md b/hipfile/hipify/README.md deleted file mode 100644 index 2ae59b4b..00000000 --- a/hipfile/hipify/README.md +++ /dev/null @@ -1,22 +0,0 @@ -rocFile hipify README ---------------------- - -This is a source patch that updates hipify so it can convert the cuFile -API to hipFile. This is a diff against the `rocm-7.0.1` tag, but can -probably be applied against other recent versions of hipify since it's -mainly appending things to the ends of lists of API calls, types, etc. - -To apply: - -1. Get the hipify source from `https://github.com/ROCm/HIPIFY` and check out the `rocm-7.0.1` tag. -2. Copy the `hipfile_hipify.diff` file to the hipfiy source root -3. Run `patch -p1 < hipfile_hipify.diff` to add the hipFile changes -4. Configure and build normally - -The produced executable will be able to convert cuFile code to hipFile. -You can get some sample programs to convert from NVIDIA's MagnumIO -GitHub repository: - -`https://github.com/NVIDIA/MagnumIO` - -The cuFile examples are in the `gds/samples` directory. diff --git a/hipfile/hipify/hipfile_hipify.diff b/hipfile/hipify/hipfile_hipify.diff deleted file mode 100644 index e9b5a8c4..00000000 --- a/hipfile/hipify/hipfile_hipify.diff +++ /dev/null @@ -1,1051 +0,0 @@ -diff --git a/src/CUDA2HIP.cpp b/src/CUDA2HIP.cpp -index 698d2f4f..7975d9eb 100644 ---- a/src/CUDA2HIP.cpp -+++ b/src/CUDA2HIP.cpp -@@ -103,6 +103,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() { -@@ -138,6 +139,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; - }; - -@@ -174,6 +177,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; - } - -@@ -210,5 +215,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 1f96c423..c20294e2 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 CUDA maps. -@@ -176,6 +182,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 HIP maps. -@@ -196,6 +206,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; - - namespace driver { - enum CUDA_DRIVER_API_SECTIONS { -diff --git a/src/CUDA2HIP_Doc.cpp b/src/CUDA2HIP_Doc.cpp -index a98d710b..e8b582dc 100644 ---- a/src/CUDA2HIP_Doc.cpp -+++ b/src/CUDA2HIP_Doc.cpp -@@ -124,6 +124,17 @@ namespace doc { - const string sROCSPARSE_csv = sROCSPARSE + csv_ext; - const string sCUSPARSE = "CUSPARSE"; - -+ /* hipFile / rocFile */ -+ const string sHIPFILE = "cuFile_API_supported_by_HIP"; -+ const string sHIPFILE_md = sHIPFILE + md_ext; -+ const string sHIPFILE_csv = sHIPFILE + csv_ext; -+ const string sHIPFILE_and_ROC_md = sHIPFILE + sandROC + md_ext; -+ const string sHIPFILE_and_ROC_csv = sHIPFILE + sandROC + csv_ext; -+ const string sROCFILE = "cuFile_API_supported_by_ROC"; -+ const string sROCFILE_md = sROCFILE + md_ext; -+ const string sROCFILE_csv = sROCFILE + 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; -@@ -842,6 +853,56 @@ namespace doc { - } - }; - -+ class HIPFILE: public DOC { -+ public: -+ HIPFILE(const string &outDir): DOC(outDir) { hasROC = true; } -+ virtual ~HIPFILE() {} -+ protected: -+ const string sMetaKeywords = "hipFile, cuFile"; -+ const string sMetaKeywordsJoint = sMetaKeywords + ", rocFile"; -+ const string &getAdditionalMetaKeywords() const override { return roc == joint ? sMetaKeywordsJoint : 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 sROC; } -+ const string &getJointAPI() const override { return sHIPandROC; } -+ const string &getFileName(docType format) const override { -+ switch (format) { -+ case none: -+ default: return sEmpty; -+ case md: return roc == joint ? sHIPFILE_and_ROC_md : sHIPFILE_md; -+ case csv: return roc == joint ? sHIPFILE_and_ROC_csv : sHIPFILE_csv; -+ } -+ } -+ }; -+ -+ class ROCFILE : public HIPFILE { -+ public: -+ ROCFILE(const string &outDir) : HIPFILE(outDir) { hasROC = false; isROC = true; } -+ virtual ~ROCFILE() {} -+ protected: -+ const string sMetaKeywords = "hipFile, cuFile, rocFile"; -+ const string &getAdditionalMetaKeywords() const override { return sMetaKeywords; } -+ const string &getAPI() const override { return sROC; } -+ const string &getFileName(docType format) const override { -+ switch (format) { -+ case none: -+ default: return sEmpty; -+ case md: return sROCFILE_md; -+ case csv: return sROCFILE_csv; -+ } -+ } -+ }; -+ - class DEVICE : public DOC { - public: - DEVICE(const string &outDir): DOC(outDir) {} -@@ -992,6 +1053,7 @@ namespace doc { - ROCSOLVER rocsolver(sOut); - MIOPEN miopen(sOut); - ROCSPARSE rocsparse(sOut); -+ ROCFILE rocfile(sOut); - RAND rand(sOut); - docs.addDoc(&rand); - ROCRAND rocrand(sOut); -@@ -1000,6 +1062,7 @@ namespace doc { - docs.addDoc(&rocrand); - docs.addDoc(&miopen); - docs.addDoc(&rocsparse); -+ docs.addDoc(&rocfile); - docs.addDoc(&rocsolver); - } - if (HipDnnSupport) { -@@ -1010,6 +1073,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..99dc07b2 ---- /dev/null -+++ b/src/CUDA2HIP_FILE_API_functions.cpp -@@ -0,0 +1,251 @@ -+#include "CUDA2HIP.h" -+ -+//struct hipCounter { -+// llvm::StringRef hipName; -+// llvm::StringRef rocName; -+// ConvTypes type; -+// ApiTypes apiType; -+// unsigned int apiSection; -+// unsigned int supportDegree; -+//}; -+ -+/* clang-format off */ -+const std::map CUDA_FILE_FUNCTION_MAP { -+ {"cufileop_status_error", {"hipFileOpStatusError", "rocFileOpStatusError", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileHandleRegister", {"hipFileHandleRegister", "rocFileHandleRegister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileHandleDeregister", {"hipFileHandleDeregister", "rocFileHandleDeregister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBufRegister", {"hipFileBufRegister", "rocFileBufRegister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBufDeregister", {"hipFileBufDeregister", "rocFileBufDeregister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileRead", {"hipFileRead", "rocFileRead", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileWrite", {"hipFileWrite", "rocFileWrite", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverOpen", {"hipFileDriverOpen", "rocFileDriverOpen", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverClose", {"hipFileDriverClose", "rocFileDriverClose", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverClose_v2", {"hipFileDriverClose", "rocFileDriverClose", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileUseCount", {"hipFileUseCount", "rocFileUseCount", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverGetProperties", {"hipFileDriverGetProperties", "rocFileDriverGetProperties", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverSetPollMode", {"hipFileDriverSetPollMode", "rocFileDriverSetPollMode", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverSetMaxDirectIOSize", {"hipFileDriverSetMaxDirectIOSize", "rocFileDriverSetMaxDirectIOSize", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverSetMaxCacheSize", {"hipFileDriverSetMaxCacheSize", "rocFileDriverSetMaxCacheSize", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileDriverSetMaxPinnedMemSize", {"hipFileDriverSetMaxPinnedMemSize", "rocFileDriverSetMaxPinnedMemSize", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileWriteAsync", {"hipFileWriteAsync", "rocFileWriteAsync", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileReadAsync", {"hipFileReadAsync", "rocFileReadAsync", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileStreamRegister", {"hipFileStreamRegister", "rocFileStreamRegister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileStreamDeregister", {"hipFileStreamDeregister", "rocFileStreamDeregister", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileGetVersion", {"hipFileGetBackendVersion", "rocFileGetCompatVersion", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBatchIOSetUp", {"hipFileBatchIOSetUp", "rocFileBatchIOSetUp", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBatchIOSubmit", {"hipFileBatchIOSubmit", "rocFileBatchIOSubmit", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBatchIOGetStatus", {"hipFileBatchIOGetStatus", "rocFileBatchIOGetStatus", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBatchIOCancel", {"hipFileBatchIOCancel", "rocFileBatchIOCancel", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileBatchIODestroy", {"hipFileBatchIODestroy", "rocFileBatchIODestroy", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileGetParameterSizeT", {"hipFileGetParameterSizeT", "rocFileGetParameterSizeT", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileGetParameterBool", {"hipFileGetParameterBool", "rocFileGetParameterBool", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileGetParameterString", {"hipFileGetParameterString", "rocFileGetParameterString", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileSetParameterSizeT", {"hipFileSetParameterSizeT", "rocFileSetParameterSizeT", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileSetParameterBool", {"hipFileSetParameterBool", "rocFileSetParameterBool", CONV_LIB_FUNC, API_FILE, 4, FULL}}, -+ {"cuFileSetParameterString", {"hipFileSetParameterString", "rocFileSetParameterString", CONV_LIB_FUNC, API_FILE, 4, 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}}, -+ {"hipFileGetBackendVersion", {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}}, -+ -+ {"rocFileOpStatusError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleRegister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleDeregister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBufRegister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBufDeregister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileRead", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileWrite", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverOpen", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverClose", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileUseCount", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverGetProperties", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverSetPollMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverSetMaxDirectIOSize", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverSetMaxCacheSize", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverSetMaxPinnedMemSize", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileWriteAsync", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileReadAsync", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileStreamRegister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileStreamDeregister", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGetCompatVersion", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIOSetUp", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIOSubmit", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIOGetStatus", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIOCancel", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIODestroy", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGetParameterSizeT", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGetParameterBool", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGetParameterString", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSetParameterSizeT", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSetParameterBool", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSetParameterString", {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}}, -+ {"cuFileGetVersion", {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}}, -+ {"cuFileGetVersion", {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_0}}, -+ {"hipFileHandleDeregister", {HIP_0}}, -+ {"hipFileBufRegister", {HIP_0}}, -+ {"hipFileBufDeregister", {HIP_0}}, -+ {"hipFileRead", {HIP_0}}, -+ {"hipFileWrite", {HIP_0}}, -+ {"hipFileDriverOpen", {HIP_0}}, -+ {"hipFileDriverClose", {HIP_0}}, -+ {"hipFileUseCount", {HIP_0}}, -+ {"hipFileDriverGetProperties", {HIP_0}}, -+ {"hipFileDriverSetPollMode", {HIP_0}}, -+ {"hipFileDriverSetMaxDirectIOSize", {HIP_0}}, -+ {"hipFileDriverSetMaxCacheSize", {HIP_0}}, -+ {"hipFileDriverSetMaxPinnedMemSize", {HIP_0}}, -+ {"hipFileWriteAsync", {HIP_0}}, -+ {"hipFileReadAsync", {HIP_0}}, -+ {"hipFileStreamRegister", {HIP_0}}, -+ {"hipFileStreamDeregister", {HIP_0}}, -+ {"hipFileGetBackendVersion", {HIP_0}}, -+ {"hipFileBatchIOSetUp", {HIP_0}}, -+ {"hipFileBatchIOSubmit", {HIP_0}}, -+ {"hipFileBatchIOGetStatus", {HIP_0}}, -+ {"hipFileBatchIOCancel", {HIP_0}}, -+ {"hipFileBatchIODestroy", {HIP_0}}, -+ {"hipFileGetParameterSizeT", {HIP_0}}, -+ {"hipFileGetParameterBool", {HIP_0}}, -+ {"hipFileGetParameterString", {HIP_0}}, -+ {"hipFileSetParameterSizeT", {HIP_0}}, -+ {"hipFileSetParameterBool", {HIP_0}}, -+ {"hipFileSetParameterString", {HIP_0}}, -+ -+ {"rocFileHandleRegister", {HIP_0}}, -+ {"rocFileHandleDeregister", {HIP_0}}, -+ {"rocFileBufRegister", {HIP_0}}, -+ {"rocFileBufDeregister", {HIP_0}}, -+ {"rocFileRead", {HIP_0}}, -+ {"rocFileWrite", {HIP_0}}, -+ {"rocFileDriverOpen", {HIP_0}}, -+ {"rocFileDriverClose", {HIP_0}}, -+ {"rocFileUseCount", {HIP_0}}, -+ {"rocFileDriverGetProperties", {HIP_0}}, -+ {"rocFileDriverSetPollMode", {HIP_0}}, -+ {"rocFileDriverSetMaxDirectIOSize", {HIP_0}}, -+ {"rocFileDriverSetMaxCacheSize", {HIP_0}}, -+ {"rocFileDriverSetMaxPinnedMemSize", {HIP_0}}, -+ {"rocFileWriteAsync", {HIP_0}}, -+ {"rocFileReadAsync", {HIP_0}}, -+ {"rocFileStreamRegister", {HIP_0}}, -+ {"rocFileStreamDeregister", {HIP_0}}, -+ {"rocFileCompatGetVersion", {HIP_0}}, -+ {"rocFileBatchIOSetUp", {HIP_0}}, -+ {"rocFileBatchIOSubmit", {HIP_0}}, -+ {"rocFileBatchIOGetStatus", {HIP_0}}, -+ {"rocFileBatchIOCancel", {HIP_0}}, -+ {"rocFileBatchIODestroy", {HIP_0}}, -+ {"rocFileGetParameterSizeT", {HIP_0}}, -+ {"rocFileGetParameterBool", {HIP_0}}, -+ {"rocFileGetParameterString", {HIP_0}}, -+ {"rocFileSetParameterSizeT", {HIP_0}}, -+ {"rocFileSetParameterBool", {HIP_0}}, -+ {"rocFileSetParameterString", {HIP_0}}, -+}; -+ -+const std::map CUDA_FILE_API_SECTION_MAP { -+ {4, "cuFile API"}, -+}; -diff --git a/src/CUDA2HIP_FILE_API_types.cpp b/src/CUDA2HIP_FILE_API_types.cpp -new file mode 100644 -index 00000000..49f21ab6 ---- /dev/null -+++ b/src/CUDA2HIP_FILE_API_types.cpp -@@ -0,0 +1,529 @@ -+#include "CUDA2HIP.h" -+ -+//struct hipCounter { -+// llvm::StringRef hipName; -+// llvm::StringRef rocName; -+// ConvTypes type; -+// ApiTypes apiType; -+// unsigned int apiSection; -+// unsigned int supportDegree; -+//}; -+ -+const std::map CUDA_FILE_TYPE_NAME_MAP { -+ {"CUfileOpError", {"hipFileOpError_t", "rocFileOpError_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileError_t", {"hipFileError_t", "rocFileError_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileDriverStatusFlags_t", {"hipFileDriverStatusFlags_t", "rocFileDriverStatusFlags_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileDriverControlFlags_t", {"hipFileDriverControlFlags_t", "rocFileDriverControlFlags_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileFeatureFlags_t", {"hipFileFeatureFlags_t", "rocFileFeatureFlags_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileFileHandleType", {"hipFileFileHandleType", "rocFileFileHandleType", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileDrvProps_t", {"hipFileDriverProps_t", "rocFileDriverProps_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"cufileRDMAInfo_t", {"hipFileRDMAInfo_t", "rocFileRDMAInfo_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileFSOps_t", {"hipFileFSOps_t", "rocFileFSOps_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileDescr_t", {"hipFileDescr_t", "rocFileDescr_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileHandle_t", {"hipFileHandle_t", "rocFileHandle_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileIOParams_t", {"hipFileIOParams_t", "rocFileIOParams_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileIOEvents_t", {"hipFileIOEvents_t", "rocFileIOEvents_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileOpcode_t", {"hipFileOpcode_t", "rocFileOpcode_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileStatus_t", {"hipFileStatus_t", "rocFileStatus_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileBatchHandle_t", {"hipFileBatchHandle_t", "rocFileBatchHandle_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUfileBatchMode_t", {"hipFileBatchMode_t", "rocFileBatchMode_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUFileSizeTConfigParameter_t", {"hipFileSizeTConfigParameter_t", "rocFileSizeTConfigParameter_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUFileBoolConfigParameter_t", {"hipFileBoolConfigParameter_t", "rocFileBoolConfigParameter_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CUFileStringConfigParameter_t", {"hipFileStringConfigParameter_t", "rocFileStringConfigParameter_t", CONV_TYPE, API_FILE, 4, FULL}}, -+ {"CU_FILE_SUCCESS", {"hipFileSuccess", "rocFileSuccess", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_NOT_INITIALIZED", {"hipFileDriverNotInitialized", "rocFileDriverNotInitialized", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_INVALID_PROPS", {"hipFileDriverInvalidProps", "rocFileDriverInvalidProps", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_UNSUPPORTED_LIMIT", {"hipFileDriverUnsupportedLimit", "rocFileDriverUnsupportedLimit", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_VERSION_MISMATCH", {"hipFileDriverVersionMismatch", "rocFileDriverVersionMismatch", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_VERSION_READ_ERROR", {"hipFileDriverVersionReadError", "rocFileDriverVersionReadError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_CLOSING", {"hipFileDriverClosing", "rocFileDriverClosing", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_PLATFORM_NOT_SUPPORTED", {"hipFilePlatformNotSupported", "rocFilePlatformNotSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_IO_NOT_SUPPORTED", {"hipFileIONotSupported", "rocFileIONotSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DEVICE_NOT_SUPPORTED", {"hipFileDeviceNotSupported", "rocFileDeviceNotSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVFS_DRIVER_ERROR", {"hipFileDriverError", "rocFileDriverError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_CUDA_DRIVER_ERROR", {"hipFileHipDriverError", "rocFileHipDriverError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_CUDA_POINTER_INVALID", {"hipFileHipPointerInvalid", "rocFileHipPointerInvalid", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_CUDA_MEMORY_TYPE_INVALID", {"hipFileHipMemoryTypeInvalid", "rocFileHipMemoryTypeInvalid", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_CUDA_POINTER_RANGE_ERROR", {"hipFileHipPointerRangeError", "rocFileHipPointerRangeError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_CUDA_CONTEXT_MISMATCH", {"hipFileHipContextMismatch", "rocFileHipContextMismatch", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INVALID_MAPPING_SIZE", {"hipFileInvalidMappingSize", "rocFileInvalidMappingSize", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INVALID_MAPPING_RANGE", {"hipFileInvalidMappingRange", "rocFileInvalidMappingRange", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INVALID_FILE_TYPE", {"hipFileInvalidFileType", "rocFileInvalidFileType", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INVALID_FILE_OPEN_FLAG", {"hipFileInvalidFileOpenFlag", "rocFileInvalidFileOpenFlag", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DIO_NOT_SET", {"hipFileDIONotSet", "rocFileDIONotSet", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INVALID_VALUE", {"hipFileInvalidValue", "rocFileInvalidValue", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_MEMORY_ALREADY_REGISTERED", {"hipFileMemoryAlreadyRegistered", "rocFileMemoryAlreadyRegistered", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_MEMORY_NOT_REGISTERED", {"hipFileMemoryNotRegistered", "rocFileMemoryNotRegistered", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_PERMISSION_DENIED", {"hipFilePermissionDenied", "rocFilePermissionDenied", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DRIVER_ALREADY_OPEN", {"hipFileDriverAlreadyOpen", "rocFileDriverAlreadyOpen", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_HANDLE_NOT_REGISTERED", {"hipFileHandleNotRegistered", "rocFileHandleNotRegistered", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_HANDLE_ALREADY_REGISTERED", {"hipFileHandleAlreadyRegistered", "rocFileHandleAlreadyRegistered", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DEVICE_NOT_FOUND", {"hipFileDeviceNotFound", "rocFileDeviceNotFound", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_INTERNAL_ERROR", {"hipFileInternalError", "rocFileInternalError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_GETNEWFD_FAILED", {"hipFileGetNewFDFailed", "rocFileGetNewFDFailed", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVFS_SETUP_ERROR", {"hipFileDriverSetupError", "rocFileDriverSetupError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_IO_DISABLED", {"hipFileIODisabled", "rocFileIODisabled", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_BATCH_SUBMIT_FAILED", {"hipFileBatchSubmitFailed", "rocFileBatchSubmitFailed", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_GPU_MEMORY_PINNING_FAILED", {"hipFileGPUMemoryPinningFailed", "rocFileGPUMemoryPinningFailed", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_BATCH_FULL", {"hipFileBatchFull", "rocFileBatchFull", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_ASYNC_NOT_SUPPORTED", {"hipFileAsyncNotSupported", "rocFileAsyncNotSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_IO_MAX_ERROR", {"hipFileIOMaxError", "rocFileIOMaxError", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_LUSTRE_SUPPORTED", {"hipFileLustreSupported", "rocFileLustreSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_WEKAFS_SUPPORTED", {"hipFileWekaFSSupported", "rocFileWekaFSSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NFS_SUPPORTED", {"hipFileNFSSupported", "rocFileNFSSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_GPFS_SUPPORTED", {"hipFileGPFSSupported", "rocFileGPFSSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVME_SUPPORTED", {"hipFileNVMeSupported", "rocFileNVMeSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVMEOF_SUPPORTED", {"hipFileNVMeoFSupported", "rocFileNVMeoFSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_SCSI_SUPPORTED", {"hipFileSCSISupported", "rocFileSCSISupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_SCALEFLUX_CSD_SUPPORTED", {"hipFileScaleFluxCSDSupported", "rocFileScaleFluxCSDSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVMESH_SUPPORTED", {"hipFileNVMeshSupported", "rocFileNVMeshSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_BEEGFS_SUPPORTED", {"hipFileBEEGFSSupported", "rocFileBEEGFSSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_NVME_P2P_SUPPORTED", {"hipFileNVMeP2PSsupported", "rocFileNVMeP2PSsupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_USE_POLL_MODE", {"hipFileUsePollMode", "rocFileUsePollMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_ALLOW_COMPAT_MODE", {"hipFileAllowCompatMode", "rocFileAllowCompatMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_DYN_ROUTING_SUPPORTED", {"hipFileDynRoutingSupported", "rocFileDynRoutingSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_BATCH_IO_SUPPORTED", {"hipFileBatchIOSupported", "rocFileBatchIOSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_STREAMS_SUPPORTED", {"hipFileStreamsSupported", "rocFileStreamsSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_PARALLEL_IO_SUPPORTED", {"hipFileParallelIOSupported", "rocFileParallelIOSupported", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_RDMA_REGISTER", {"HIPFILE_RDMA_REGISTER", "ROCFILE_RDMA_REGISTER", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_RDMA_RELAXED_ORDERING", {"HIPFILE_RDMA_RELAXED_ORDERING", "ROCFILE_RDMA_RELAXED_ORDERING", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_HANDLE_TYPE_OPAQUE_FD", {"hipFileHandleTypeOpaqueFD", "rocFileHandleTypeOpaqueFD", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_HANDLE_TYPE_OPAQUE_WIN32", {"hipFileHandleTypeOpaqueWin32", "rocFileHandleTypeOpaqueWin32", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_HANDLE_TYPE_USERSPACE_FS", {"hipFileHandleTypeUserspaceFS", "rocFileHandleTypeUserspaceFS", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_READ", {"hipFileBatchRead", "rocFileBatchRead", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_WRITE", {"hipFileBatchWrite", "rocFileBatchWrite", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_WAITING", {"hipFileWaiting", "rocFileWaiting", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PENDING", {"hipFilePending", "rocFilePending", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_INVALID", {"hipFileInvalid", "rocFileInvalid", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_CANCELED", {"hipFileCanceled", "rocFileCanceled", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_COMPLETE", {"hipFileComplete", "rocFileComplete", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_TIMEOUT", {"hipFileTimeout", "rocFileTimeout", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_FAILED", {"hipFileFailed", "rocFileFailed", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_BATCH", {"hipFileBatch", "rocFileBatch", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_STREAM_FIXED_BUF_OFFSET", {"HIPFILE_STREAM_FIXED_BUF_OFFSET", "ROCFILE_STREAM_FIXED_BUF_OFFSET", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_STREAM_FIXED_FILE_OFFSET", {"HIPFILE_STREAM_FIXED_FILE_OFFSET", "ROCFILE_STREAM_FIXED_FILE_OFFSET", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_STREAM_FIXED_FILE_SIZE", {"HIPFILE_STREAM_FIXED_FILE_SIZE", "ROCFILE_STREAM_FIXED_FILE_SIZE", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CU_FILE_STREAM_PAGE_ALIGNED_INPUTS", {"HIPFILE_STREAM_PAGE_ALIGNED_INPUTS", "ROCFILE_STREAM_PAGE_ALIGNED_INPUTS", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROFILE_STATS", {"hipFileParamProfileStats", "rocFileParamProfileStats", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH", {"hipFileParamExecutionMaxIOQueueDepth", "rocFileParamExecutionMaxIOQueueDepth", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_EXECUTION_MAX_IO_THREADS", {"hipFileParamExecutionMaxIOThreads", "rocFileParamExecutionMaxIOThreads", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB", {"hipFileParamExecutionMinIOThresholdSizeKB", "rocFileParamExecutionMinIOThresholdSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM", {"hipFileParamExecutionMaxRequestParallelism", "rocFileParamExecutionMaxRequestParallelism", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB", {"hipFileParamPropertiesMaxDirectIOSizeKB", "rocFileParamPropertiesMaxDirectIOSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB", {"hipFileParamPropertiesMaxDeviceCacheSizeKB", "rocFileParamPropertiesMaxDeviceCacheSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB", {"hipFileParamPropertiesPerBufferCacheSizeKB", "rocFileParamPropertiesPerBufferCacheSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB", {"hipFileParamPropertiesMaxDevicePinnedMemSizeKB", "rocFileParamPropertiesMaxDevicePinnedMemSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE", {"hipFileParamPropertiesIOBatchsize", "rocFileParamPropertiesIOBatchsize", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB", {"hipFileParamPollthresholdSizeKB", "rocFileParamPollthresholdSizeKB", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS", {"hipFileParamPropertiesBatchIOTimeoutMs", "rocFileParamPropertiesBatchIOTimeoutMs", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_USE_POLL_MODE", {"hipFileParamPropertiesUsePollMode", "rocFileParamPropertiesUsePollMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE", {"hipFileParamPropertiesAllowCompatMode", "rocFileParamPropertiesAllowCompatMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_FORCE_COMPAT_MODE", {"hipFileParamForceCompatMode", "rocFileParamForceCompatMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE", {"hipFileParamFsMiscApiCheckAggressive", "rocFileParamFsMiscApiCheckAggressive", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_EXECUTION_PARALLEL_IO", {"hipFileParamExecutionParallelIO", "rocFileParamExecutionParallelIO", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROFILE_NVTX", {"hipFileParamProfileNvtx", "rocFileParamProfileNvtx", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY", {"hipFileParamPropertiesAllowSystemMemory", "rocFileParamPropertiesAllowSystemMemory", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_USE_PCIP2PDMA", {"hipFileParamUsePcip2pdma", "rocFileParamUsePcip2pdma", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_PREFER_IO_URING", {"hipFileParamPreferIOUring", "rocFileParamPreferIOUring", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_FORCE_ODIRECT_MODE", {"hipFileParamForceOdirectMode", "rocFileParamForceOdirectMode", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION", {"hipFileParamSkipTopologyDetection", "rocFileParamSkipTopologyDetection", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_STREAM_MEMOPS_BYPASS", {"hipFileParamStreamMemopsBypass", "rocFileParamStreamMemopsBypass", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_LOGGING_LEVEL", {"hipFileParamLoggingLevel", "rocFileParamLoggingLevel", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_ENV_LOGFILE_PATH", {"hipFileParamEnvLogfilePath", "rocFileParamEnvLogfilePath", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"CUFILE_PARAM_LOG_DIR", {"hipFileParamLogDir", "rocFileParamLogDir", CONV_NUMERIC_LITERAL, API_FILE, 4, FULL}}, -+ {"IS_CUFILE_ERR", {"IS_HIPFILE_ERR", "IS_ROCFILE_ERR", CONV_DEFINE, API_FILE, 4, FULL}}, -+ {"CUFILE_ERRSTR", {"HIPFILE_ERRSTR", "ROCFILE_ERRSTR", CONV_DEFINE, API_FILE, 4, FULL}}, -+ {"CUDA_DRV_ERR", {"HIP_DRV_ERR", "HIP_DRV_ERR", CONV_DEFINE, API_FILE, 4, FULL}}, -+ {"IS_CUDA_ERR", {"IS_HIP_DRV_ERR", "IS_HIP_DRV_ERR", CONV_DEFINE, API_FILE, 4, 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}}, -+ -+ {"rocFileOpError_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileError_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverStatusFlags_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverControlFlags_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileFeatureFlags_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileFileHandleType", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverProps_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileRDMAInfo_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileFSOps_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDescr_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandle_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileIOParams_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileIOEvents_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileOpcode_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileStatus_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchHandle_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchMode_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSizeTConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBoolConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileStringConfigParameter_t", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSuccess", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverNotInitialized", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverInvalidProps", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverUnsupportedLimit", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverVersionMismatch", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverVersionReadError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverClosing", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFilePlatformNotSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileIONotSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDeviceNotSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHipDriverError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHipPointerInvalid", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHipMemoryTypeInvalid", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHipPointerRangeError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHipContextMismatch", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalidMappingSize", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalidMappingRange", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalidFileType", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalidFileOpenFlag", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDIONotSet", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalidValue", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileMemoryAlreadyRegistered", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileMemoryNotRegistered", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFilePermissionDenied", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverAlreadyOpen", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleNotRegistered", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleAlreadyRegistered", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDeviceNotFound", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInternalError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGetNewFDFailed", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDriverSetupError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileIODisabled", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchSubmitFailed", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGPUMemoryPinningFailed", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchFull", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileAsyncNotSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileIOMaxError", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileLustreSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileWekaFSSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileNFSSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileGPFSSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileNVMeSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileNVMeoFSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileSCSISupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileScaleFluxCSDSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileNVMeshSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBEEGFSSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileNVMeP2PSsupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileUsePollMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileAllowCompatMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileDynRoutingSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchIOSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileStreamsSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParallelIOSupported", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_RDMA_REGISTER", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_RDMA_RELAXED_ORDERING", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleTypeOpaqueFD", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleTypeOpaqueWin32", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileHandleTypeUserspaceFS", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchRead", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatchWrite", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileWaiting", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFilePending", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileInvalid", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileCanceled", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileComplete", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileTimeout", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileFailed", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileBatch", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_STREAM_FIXED_BUF_OFFSET", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_STREAM_FIXED_FILE_OFFSET", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_STREAM_FIXED_FILE_SIZE", {HIP_7000, HIP_0, HIP_0}}, -+ {"ROCFILE_STREAM_PAGE_ALIGNED_INPUTS", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamProfileStats", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamExecutionMaxIOQueueDepth", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamExecutionMaxIOThreads", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamExecutionMinIOThresholdSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamExecutionMaxRequestParallelism", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesMaxDirectIOSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesMaxDeviceCacheSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesPerBufferCacheSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesMaxDevicePinnedMemSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesIOBatchsize", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPollthresholdSizeKB", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesBatchIOTimeoutMs", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesUsePollMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesAllowCompatMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamForceCompatMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamFsMiscApiCheckAggressive", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamExecutionParallelIO", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamProfileNvtx", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPropertiesAllowSystemMemory", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamUsePcip2pdma", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamPreferIOUring", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamForceOdirectMode", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamSkipTopologyDetection", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamStreamMemopsBypass", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamLoggingLevel", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamEnvLogfilePath", {HIP_7000, HIP_0, HIP_0}}, -+ {"rocFileParamLogDir", {HIP_7000, HIP_0, HIP_0}}, -+ {"IS_HIPFILE_ERR", {HIP_7000, HIP_0, HIP_0}}, -+ {"HIPFILE_ERRSTR", {HIP_7000, HIP_0, HIP_0}}, -+}; -diff --git a/src/HipifyAction.cpp b/src/HipifyAction.cpp -index 18a20097..4aa82400 100644 ---- a/src/HipifyAction.cpp -+++ b/src/HipifyAction.cpp -@@ -2426,6 +2426,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 @@ private: - 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 5bd53cfe..69301212 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 445c510d..1c2d1a98 100644 ---- a/src/Statistics.h -+++ b/src/Statistics.h -@@ -183,6 +183,7 @@ enum ApiTypes { - API_CAFFE2, - API_RTC, - API_TENSOR, -+ API_FILE, - API_LAST - }; - constexpr int NUM_API_TYPES = (int) ApiTypes::API_LAST;