From 4812d8e78b12104ed9075db4dbda26d466490519 Mon Sep 17 00:00:00 2001 From: Shadi Dashmiz <94885391+shadidashmiz@users.noreply.github.com> Date: Mon, 8 Dec 2025 10:37:03 -0500 Subject: [PATCH] SWDEV-566783 - clean up cmgr helper (#1864) Signed-off-by: sdashmiz --- projects/clr/hipamd/src/hip_comgr_helper.cpp | 371 ++++++------------ projects/clr/hipamd/src/hip_comgr_helper.hpp | 188 ++++++--- projects/clr/hipamd/src/hip_fatbin.cpp | 68 +--- .../clr/hipamd/src/hiprtc/hiprtcInternal.cpp | 4 +- .../clr/hipamd/src/hiprtc/hiprtcInternal.hpp | 9 +- 5 files changed, 263 insertions(+), 377 deletions(-) diff --git a/projects/clr/hipamd/src/hip_comgr_helper.cpp b/projects/clr/hipamd/src/hip_comgr_helper.cpp index 8171dbcd7d..2b3032fea1 100644 --- a/projects/clr/hipamd/src/hip_comgr_helper.cpp +++ b/projects/clr/hipamd/src/hip_comgr_helper.cpp @@ -28,6 +28,10 @@ THE SOFTWARE. namespace hip { std::unordered_set LinkProgram::linker_set_; +using hip::comgr_helper::ComgrActionInfoUniqueHandle; +using hip::comgr_helper::ComgrDataSetUniqueHandle; +using hip::comgr_helper::ComgrDataUniqueHandle; + namespace helpers { size_t constexpr strLiteralLength(char const* str) { @@ -197,38 +201,29 @@ bool UnbundleBitCode(const std::vector& bundled_llvm_bitcode, const std::s return true; } -bool addCodeObjData(amd_comgr_data_set_t& input, const std::vector& source, +bool addCodeObjData(comgr_helper::ComgrDataSetUniqueHandle& input, const std::vector& source, const std::string& name, const amd_comgr_data_kind_t type) { - amd_comgr_data_t data; - - if (auto res = amd::Comgr::create_data(type, &data); res != AMD_COMGR_STATUS_SUCCESS) { + comgr_helper::ComgrDataUniqueHandle data; + if (data.Create(type) != AMD_COMGR_STATUS_SUCCESS) { return false; } - - if (auto res = amd::Comgr::set_data(data, source.size(), source.data()); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::release_data(data); + if (amd::Comgr::set_data(data.get(), source.size(), source.data()) != AMD_COMGR_STATUS_SUCCESS) { return false; } - - if (auto res = amd::Comgr::set_data_name(data, name.c_str()); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::release_data(data); + if (amd::Comgr::set_data_name(data.get(), name.c_str()) != AMD_COMGR_STATUS_SUCCESS) { return false; } - - if (auto res = amd::Comgr::data_set_add(input, data); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::release_data(data); + if (amd::Comgr::data_set_add(input.get(), data.get()) != AMD_COMGR_STATUS_SUCCESS) { return false; } - amd::Comgr::release_data(data); // Release from our end after setting the input return true; } -bool extractBuildLog(amd_comgr_data_set_t dataSet, std::string& buildLog) { +bool extractBuildLog(comgr_helper::ComgrDataSetUniqueHandle& dataSet, std::string& buildLog) { size_t count; - if (auto res = amd::Comgr::action_data_count(dataSet, AMD_COMGR_DATA_KIND_LOG, &count); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::action_data_count(dataSet.get(), AMD_COMGR_DATA_KIND_LOG, &count) != + AMD_COMGR_STATUS_SUCCESS) { return false; } @@ -240,19 +235,17 @@ bool extractBuildLog(amd_comgr_data_set_t dataSet, std::string& buildLog) { return true; } -bool extractByteCodeBinary(const amd_comgr_data_set_t inDataSet, +bool extractByteCodeBinary(const comgr_helper::ComgrDataSetUniqueHandle& inDataSet, const amd_comgr_data_kind_t dataKind, std::vector& bin) { - amd_comgr_data_t binaryData; + amd_comgr_data_t binaryDataHandle; - if (auto res = amd::Comgr::action_data_get_data(inDataSet, dataKind, 0, &binaryData); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::action_data_get_data(inDataSet.get(), dataKind, 0, &binaryDataHandle) != + AMD_COMGR_STATUS_SUCCESS) { return false; } - + comgr_helper::ComgrDataUniqueHandle binaryData(binaryDataHandle); size_t binarySize = 0; - if (auto res = amd::Comgr::get_data(binaryData, &binarySize, NULL); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::release_data(binaryData); + if (amd::Comgr::get_data(binaryData.get(), &binarySize, NULL) != AMD_COMGR_STATUS_SUCCESS) { return false; } @@ -260,15 +253,11 @@ bool extractByteCodeBinary(const amd_comgr_data_set_t inDataSet, char* binary = new char[bufSize]; if (binary == nullptr) { - amd::Comgr::release_data(binaryData); return false; } - - if (auto res = amd::Comgr::get_data(binaryData, &binarySize, binary); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::get_data(binaryData.get(), &binarySize, binary) != AMD_COMGR_STATUS_SUCCESS) { delete[] binary; - amd::Comgr::release_data(binaryData); return false; } @@ -276,8 +265,6 @@ bool extractByteCodeBinary(const amd_comgr_data_set_t inDataSet, binary[binarySize] = '\0'; } - amd::Comgr::release_data(binaryData); - std::vector temp_bin; temp_bin.assign(binary, binary + binarySize); bin = temp_bin; @@ -286,23 +273,20 @@ bool extractByteCodeBinary(const amd_comgr_data_set_t inDataSet, return true; } -bool createAction(amd_comgr_action_info_t& action, std::vector& options, - const std::string& isa, const amd_comgr_language_t lang) { - if (auto res = amd::Comgr::create_action_info(&action); res != AMD_COMGR_STATUS_SUCCESS) { +bool createAction(comgr_helper::ComgrActionInfoUniqueHandle& action, + std::vector& options, const std::string& isa, + const amd_comgr_language_t lang) { + if (action.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } if (lang != AMD_COMGR_LANGUAGE_NONE) { - if (auto res = amd::Comgr::action_info_set_language(action, lang); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (amd::Comgr::action_info_set_language(action.get(), lang) != AMD_COMGR_STATUS_SUCCESS) { return false; } } - if (auto res = amd::Comgr::action_info_set_isa_name(action, isa.c_str()); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (amd::Comgr::action_info_set_isa_name(action.get(), isa.c_str()) != AMD_COMGR_STATUS_SUCCESS) { return false; } @@ -312,144 +296,102 @@ bool createAction(amd_comgr_action_info_t& action, std::vector& opt optionsArgv.push_back(option.c_str()); } - if (auto res = - amd::Comgr::action_info_set_option_list(action, optionsArgv.data(), optionsArgv.size()); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (amd::Comgr::action_info_set_option_list(action.get(), optionsArgv.data(), + optionsArgv.size()) != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::action_info_set_logging(action, true); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (amd::Comgr::action_info_set_logging(action.get(), true) != AMD_COMGR_STATUS_SUCCESS) { return false; } return true; } -bool compileToExecutable(const amd_comgr_data_set_t compileInputs, const std::string& isa, - std::vector& compileOptions, +bool compileToExecutable(const comgr_helper::ComgrDataSetUniqueHandle& compileInputs, + const std::string& isa, std::vector& compileOptions, std::vector& linkOptions, std::string& buildLog, std::vector& exe) { amd_comgr_language_t lang = AMD_COMGR_LANGUAGE_HIP; - amd_comgr_action_info_t action; - amd_comgr_data_set_t reloc; - amd_comgr_data_set_t output; - amd_comgr_data_set_t input = compileInputs; + comgr_helper::ComgrDataSetUniqueHandle reloc; + comgr_helper::ComgrDataSetUniqueHandle output; + comgr_helper::ComgrActionInfoUniqueHandle compileAction; - if (!createAction(action, compileOptions, isa, lang)) { + if (!createAction(compileAction, compileOptions, isa, lang)) { return false; } - if (auto res = amd::Comgr::create_data_set(&reloc); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (reloc.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::create_data_set(&output); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(reloc); + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_COMPILE_SOURCE_TO_RELOCATABLE, action, - input, reloc); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::do_action(AMD_COMGR_ACTION_COMPILE_SOURCE_TO_RELOCATABLE, compileAction.get(), + compileInputs.get(), reloc.get()) != AMD_COMGR_STATUS_SUCCESS) { extractBuildLog(reloc, buildLog); - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(reloc); - amd::Comgr::destroy_data_set(output); return false; } if (!extractBuildLog(reloc, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(reloc); - amd::Comgr::destroy_data_set(output); return false; } - amd::Comgr::destroy_action_info(action); - if (!createAction(action, linkOptions, isa, lang)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(reloc); - amd::Comgr::destroy_data_set(output); + comgr_helper::ComgrActionInfoUniqueHandle linkAction; + + if (!createAction(linkAction, linkOptions, isa, lang)) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE, action, - reloc, output); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE, linkAction.get(), + reloc.get(), output.get()) != AMD_COMGR_STATUS_SUCCESS) { extractBuildLog(output, buildLog); - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(reloc); return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(reloc); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_EXECUTABLE, exe)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(reloc); return false; } - // Clean up - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(reloc); return true; } -bool compileToBitCode(const amd_comgr_data_set_t compileInputs, const std::string& isa, - std::vector& compileOptions, std::string& buildLog, - std::vector& LLVMBitcode) { +bool compileToBitCode(const comgr_helper::ComgrDataSetUniqueHandle& compileInputs, + const std::string& isa, std::vector& compileOptions, + std::string& buildLog, std::vector& LLVMBitcode) { amd_comgr_language_t lang = AMD_COMGR_LANGUAGE_HIP; - amd_comgr_action_info_t action; - amd_comgr_data_set_t output; - amd_comgr_data_set_t input = compileInputs; + comgr_helper::ComgrActionInfoUniqueHandle compileAction; - if (!createAction(action, compileOptions, isa, lang)) { + comgr_helper::ComgrDataSetUniqueHandle output; + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::create_data_set(&output); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (!createAction(compileAction, compileOptions, isa, lang)) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_COMPILE_SOURCE_WITH_DEVICE_LIBS_TO_BC, - action, input, output); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::do_action(AMD_COMGR_ACTION_COMPILE_SOURCE_WITH_DEVICE_LIBS_TO_BC, + compileAction.get(), compileInputs.get(), + output.get()) != AMD_COMGR_STATUS_SUCCESS) { extractBuildLog(output, buildLog); - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_BC, LLVMBitcode)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } - // Clean up - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return true; } @@ -468,16 +410,17 @@ bool UnbundleUsingComgr(std::vector& source, const std::string& isa, std::vector& linkOptions, std::string& buildLog, std::vector& unbundled_bitcode, const char* bundleEntryIDs[], size_t bundleEntryIDsCount) { - amd_comgr_data_set_t linkinput; - if (amd::Comgr::create_data_set(&linkinput) != AMD_COMGR_STATUS_SUCCESS) { + comgr_helper::ComgrDataSetUniqueHandle linkinput; + comgr_helper::ComgrActionInfoUniqueHandle action; + if (linkinput.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } + std::string name = "UnbundleCode.bc"; if (!helpers::addCodeObjData(linkinput, source, name, AMD_COMGR_DATA_KIND_BC_BUNDLE)) { return false; } - amd_comgr_action_info_t action; if (!createAction(action, linkOptions, isa, AMD_COMGR_LANGUAGE_NONE)) { return false; } @@ -487,206 +430,152 @@ bool UnbundleUsingComgr(std::vector& source, const std::string& isa, return false; } - if (amd::Comgr::action_info_set_bundle_entry_ids(action, bundleEntryIDs, bundleEntryIDsCount) != - AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (amd::Comgr::action_info_set_bundle_entry_ids( + action.get(), bundleEntryIDs, bundleEntryIDsCount) != AMD_COMGR_STATUS_SUCCESS) { return false; } - amd_comgr_data_set_t output; - if (amd::Comgr::create_data_set(&output) != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + comgr_helper::ComgrDataSetUniqueHandle output; + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_UNBUNDLE, action, linkinput, output); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); + if (amd::Comgr::do_action(AMD_COMGR_ACTION_UNBUNDLE, action.get(), linkinput.get(), + output.get()) != AMD_COMGR_STATUS_SUCCESS) { return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_BC, unbundled_bitcode)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(linkinput); return true; } -bool linkLLVMBitcode(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& linkOptions, std::string& buildLog, - std::vector& LinkedLLVMBitcode) { +bool linkLLVMBitcode(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& linkOptions, + std::string& buildLog, std::vector& LinkedLLVMBitcode) { const amd_comgr_language_t lang = AMD_COMGR_LANGUAGE_HIP; - amd_comgr_action_info_t action; + comgr_helper::ComgrActionInfoUniqueHandle action; if (!createAction(action, linkOptions, isa, lang)) { return false; } - amd_comgr_data_set_t output; - if (auto res = amd::Comgr::create_data_set(&output); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + comgr_helper::ComgrDataSetUniqueHandle output; + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_BC_TO_BC, action, linkInputs, output); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); + if (amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_BC_TO_BC, action.get(), linkInputs.get(), + output.get()) != AMD_COMGR_STATUS_SUCCESS) { return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_BC, LinkedLLVMBitcode)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return true; } -bool convertSPIRVToLLVMBC(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& linkOptions, std::string& buildLog, - std::vector& LinkedLLVMBitcode) { - amd_comgr_action_info_t action; +bool convertSPIRVToLLVMBC(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& linkOptions, + std::string& buildLog, std::vector& LinkedLLVMBitcode) { + comgr_helper::ComgrActionInfoUniqueHandle action; if (!createAction(action, linkOptions, isa, AMD_COMGR_LANGUAGE_NONE)) { return false; } - amd_comgr_data_set_t output; - if (auto res = amd::Comgr::create_data_set(&output); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + comgr_helper::ComgrDataSetUniqueHandle output; + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = - amd::Comgr::do_action(AMD_COMGR_ACTION_TRANSLATE_SPIRV_TO_BC, action, linkInputs, output); - res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); + if (amd::Comgr::do_action(AMD_COMGR_ACTION_TRANSLATE_SPIRV_TO_BC, action.get(), linkInputs.get(), + output.get()) != AMD_COMGR_STATUS_SUCCESS) { return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_BC, LinkedLLVMBitcode)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return false; } - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); return true; } -bool createExecutable(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& exeOptions, std::string& buildLog, - std::vector& executable, bool spirv_bc /* default false */) { - amd_comgr_action_info_t action; +bool createExecutable(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& exeOptions, + std::string& buildLog, std::vector& executable, + bool spirv_bc /* default false */) { + comgr_helper::ComgrActionInfoUniqueHandle codegenAction; + comgr_helper::ComgrDataSetUniqueHandle relocatableData; + comgr_helper::ComgrDataSetUniqueHandle output; - if (!createAction(action, exeOptions, isa)) { + if (!createAction(codegenAction, exeOptions, isa)) { return false; } // If SPIRV bitcode was processed, make sure we link device libs to it if (spirv_bc) { - if (auto res = amd::Comgr::action_info_set_device_lib_linking(action, true); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::action_info_set_device_lib_linking(codegenAction.get(), true) != + AMD_COMGR_STATUS_SUCCESS) { LogError("Can not link device libs to action"); - amd::Comgr::destroy_action_info(action); return false; } } - amd_comgr_data_set_t relocatableData; - if (auto res = amd::Comgr::create_data_set(&relocatableData); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); + if (relocatableData.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_CODEGEN_BC_TO_RELOCATABLE, action, - linkInputs, relocatableData); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::do_action(AMD_COMGR_ACTION_CODEGEN_BC_TO_RELOCATABLE, codegenAction.get(), + linkInputs.get(), relocatableData.get()) != AMD_COMGR_STATUS_SUCCESS) { extractBuildLog(relocatableData, buildLog); - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(relocatableData); return false; } if (!extractBuildLog(relocatableData, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(relocatableData); return false; } - - amd::Comgr::destroy_action_info(action); + comgr_helper::ComgrActionInfoUniqueHandle linkAction; std::vector emptyOpt; - if (!createAction(action, emptyOpt, isa)) { - amd::Comgr::destroy_data_set(relocatableData); + if (!createAction(linkAction, emptyOpt, isa)) { return false; } - amd_comgr_data_set_t output; - if (auto res = amd::Comgr::create_data_set(&output); res != AMD_COMGR_STATUS_SUCCESS) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(relocatableData); + if (output.Create() != AMD_COMGR_STATUS_SUCCESS) { return false; } - if (auto res = amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE, action, - relocatableData, output); - res != AMD_COMGR_STATUS_SUCCESS) { + if (amd::Comgr::do_action(AMD_COMGR_ACTION_LINK_RELOCATABLE_TO_EXECUTABLE, linkAction.get(), + relocatableData.get(), output.get()) != AMD_COMGR_STATUS_SUCCESS) { extractBuildLog(output, buildLog); - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(relocatableData); return false; } if (!extractBuildLog(output, buildLog)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(relocatableData); return false; } if (!extractByteCodeBinary(output, AMD_COMGR_DATA_KIND_EXECUTABLE, executable)) { - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(relocatableData); return false; } - amd::Comgr::destroy_action_info(action); - amd::Comgr::destroy_data_set(output); - amd::Comgr::destroy_data_set(relocatableData); - return true; } @@ -782,21 +671,19 @@ std::string handleMangledName(std::string loweredName) { bool fillMangledNames(std::vector& dataVec, std::map& mangledNames, bool isBitcode) { - amd_comgr_data_t dataObject; - if (auto res = amd::Comgr::create_data( - isBitcode ? AMD_COMGR_DATA_KIND_BC : AMD_COMGR_DATA_KIND_EXECUTABLE, &dataObject); - res != AMD_COMGR_STATUS_SUCCESS) { + comgr_helper::ComgrDataUniqueHandle dataObject; + if (dataObject.Create(isBitcode ? AMD_COMGR_DATA_KIND_BC : AMD_COMGR_DATA_KIND_EXECUTABLE) != + AMD_COMGR_STATUS_SUCCESS) { return false; } - - if (auto res = amd::Comgr::set_data(dataObject, dataVec.size(), dataVec.data())) { - amd::Comgr::release_data(dataObject); + if (amd::Comgr::set_data(dataObject.get(), dataVec.size(), dataVec.data()) != + AMD_COMGR_STATUS_SUCCESS) { return false; } size_t Count; - if (auto res = amd::Comgr::populate_name_expression_map(dataObject, &Count)) { - amd::Comgr::release_data(dataObject); + if (amd::Comgr::populate_name_expression_map(dataObject.get(), &Count) != + AMD_COMGR_STATUS_SUCCESS) { return false; } @@ -804,22 +691,20 @@ bool fillMangledNames(std::vector& dataVec, std::map(it.first.data()); - if (auto res = amd::Comgr::map_name_expression_to_symbol_name(dataObject, &Size, data, NULL)) { - amd::Comgr::release_data(dataObject); + if (amd::Comgr::map_name_expression_to_symbol_name(dataObject.get(), &Size, data, NULL) != + AMD_COMGR_STATUS_SUCCESS) { return false; } std::unique_ptr mName(new char[Size]()); - if (auto res = - amd::Comgr::map_name_expression_to_symbol_name(dataObject, &Size, data, mName.get())) { - amd::Comgr::release_data(dataObject); + if (amd::Comgr::map_name_expression_to_symbol_name(dataObject.get(), &Size, data, + mName.get()) != AMD_COMGR_STATUS_SUCCESS) { return false; } it.second = std::string(mName.get()); } - amd::Comgr::release_data(dataObject); return true; } @@ -873,7 +758,7 @@ bool IsCompatibleWithGenericTarget(const std::string& coTarget, const std::strin std::vector getLinkOptions(const LinkArguments& args) { std::vector res; - { // process optimization level + { // process optimization level std::string opt("-O"); opt += std::to_string(args.optimization_level_); res.push_back(opt); @@ -894,7 +779,7 @@ std::vector getLinkOptions(const LinkArguments& args) { RTCProgram::RTCProgram(std::string name) : name_(name) { constexpr bool kComgrVersioned = true; std::call_once(amd::Comgr::initialized, amd::Comgr::LoadLib, kComgrVersioned); - if (amd::Comgr::create_data_set(&exec_input_) != AMD_COMGR_STATUS_SUCCESS) { + if (exec_input_.Create() != AMD_COMGR_STATUS_SUCCESS) { guarantee(false, "Failed to allocate internal hiprtc structure"); } } @@ -993,7 +878,7 @@ void RTCProgram::AppendOptions(const std::string app_env_var, std::vector(&options_vals_ptr[opt_idx])); break; case hipJitOptionThreadsPerBlock: - link_args_.threads_per_block_ = - *(reinterpret_cast(&options_vals_ptr[opt_idx])); + link_args_.threads_per_block_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionWallTime: link_args_.wall_time_ = *(reinterpret_cast(options_vals_ptr[opt_idx])); @@ -1041,9 +925,8 @@ bool LinkProgram::AddLinkerOptions(unsigned int num_options, hipJitOption* optio link_args_.error_log_size_ = (reinterpret_cast(options_vals_ptr[opt_idx])); break; case hipJitOptionOptimizationLevel: - link_args_.optimization_level_ = - *(reinterpret_cast(&options_vals_ptr[opt_idx])); - break; + link_args_.optimization_level_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); + break; case hipJitOptionTargetFromContext: link_args_.target_from_hip_context_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); @@ -1052,11 +935,11 @@ bool LinkProgram::AddLinkerOptions(unsigned int num_options, hipJitOption* optio link_args_.jit_target_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionFallbackStrategy: - link_args_.fallback_strategy_ = - *(reinterpret_cast(&options_vals_ptr[opt_idx])); + link_args_.fallback_strategy_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionGenerateDebugInfo: - link_args_.generate_debug_info_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); + link_args_.generate_debug_info_ = + *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionLogVerbose: link_args_.log_verbose_ = reinterpret_cast(options_vals_ptr[opt_idx]); @@ -1107,17 +990,20 @@ bool LinkProgram::AddLinkerOptions(unsigned int num_options, hipJitOption* optio link_args_.min_cta_per_sm_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionMaxThreadsPerBlock: - link_args_.max_threads_per_block_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); + link_args_.max_threads_per_block_ = + *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionOverrideDirectiveValues: - link_args_.override_directive_values_ = *(reinterpret_cast(&options_vals_ptr[opt_idx])); + link_args_.override_directive_values_ = + *(reinterpret_cast(&options_vals_ptr[opt_idx])); break; case hipJitOptionIRtoISAOptExt: { link_args_.linker_ir2isa_args_ = reinterpret_cast(options_vals_ptr[opt_idx]); break; } case hipJitOptionIRtoISAOptCountExt: - link_args_.linker_ir2isa_args_count_ = reinterpret_cast(options_vals_ptr[opt_idx]); + link_args_.linker_ir2isa_args_count_ = + reinterpret_cast(options_vals_ptr[opt_idx]); break; default: break; @@ -1233,11 +1119,6 @@ bool LinkProgram::LinkComplete(void** bin_out, size_t* size_out) { return false; } - // If the data kind is SPIRV, convert it beforehand and pass it on to subsequent machinery - // TODO I think this can be simplified a bit, we are basically reading and writing into comgr data - // structures, do we need to do that? This might cause some errors, so adding this to come back to - // it. - amd_comgr_data_set_t link_input = link_input_; if (data_kind_ == AMD_COMGR_DATA_KIND_SPIRV) { // Convert SPIRV Unbundled code object to LLVM Bitcode std::vector llvmbc_from_spirv; @@ -1248,7 +1129,7 @@ bool LinkProgram::LinkComplete(void** bin_out, size_t* size_out) { } std::string linkedFileName = "LLVMBitcodeFromSPIRV.bc"; - if (!helpers::addCodeObjData(link_input, llvmbc_from_spirv, linkedFileName, + if (!helpers::addCodeObjData(link_input_, llvmbc_from_spirv, linkedFileName, AMD_COMGR_DATA_KIND_BC)) { LogError("Error in hip Linker: unable to add linked LLVM bitcode"); return false; @@ -1256,7 +1137,7 @@ bool LinkProgram::LinkComplete(void** bin_out, size_t* size_out) { } std::vector llvm_bitcode; - if (!helpers::linkLLVMBitcode(link_input, isa_, link_options_, build_log_, llvm_bitcode)) { + if (!helpers::linkLLVMBitcode(link_input_, isa_, link_options_, build_log_, llvm_bitcode)) { LogError("Error in hip linker: unable to add device libs to linked bitcode"); return false; } diff --git a/projects/clr/hipamd/src/hip_comgr_helper.hpp b/projects/clr/hipamd/src/hip_comgr_helper.hpp index bdc29a6d1c..ce00d0db4a 100644 --- a/projects/clr/hipamd/src/hip_comgr_helper.hpp +++ b/projects/clr/hipamd/src/hip_comgr_helper.hpp @@ -33,33 +33,98 @@ THE SOFTWARE. #include "hip/hip_runtime_api.h" namespace hip { + +// RAII wrapper for Comgr handles to ensure proper resource management +namespace comgr_helper { + +template class ComgrUniqueHandle { + public: + ComgrUniqueHandle() = default; + // constructor which takes ownership of a correctly initialized handle + ComgrUniqueHandle(comgr_T& handle) : comgr_obj_(handle) { handle = {0}; }; + + template || + std::is_same_v, + bool> = true> + [[nodiscard]] amd_comgr_status_t Create() { + if constexpr (std::is_same_v) { + return amd::Comgr::create_data_set(&comgr_obj_); + } else if constexpr (std::is_same_v) { + return amd::Comgr::create_action_info(&comgr_obj_); + } + + // Unreachable code + return AMD_COMGR_STATUS_SUCCESS; + } + + template , bool> = true> + [[nodiscard]] amd_comgr_status_t Create(amd_comgr_data_kind_t kind) { + return amd::Comgr::create_data(kind, &comgr_obj_); + } + + ~ComgrUniqueHandle() { + if (comgr_obj_.handle != 0) { + if constexpr (std::is_same_v) { + amd::Comgr::destroy_data_set(comgr_obj_); + } else if constexpr (std::is_same_v) { + amd::Comgr::destroy_action_info(comgr_obj_); + } else if constexpr (std::is_same_v) { + amd::Comgr::release_data(comgr_obj_); + } + } + } + + // Delete all copy and move operators + ComgrUniqueHandle(ComgrUniqueHandle&) = delete; + ComgrUniqueHandle(ComgrUniqueHandle&&) = delete; + ComgrUniqueHandle& operator=(ComgrUniqueHandle&) = delete; + ComgrUniqueHandle& operator=(ComgrUniqueHandle&&) = delete; + + // Method to access data + comgr_T get() const { + assert(comgr_obj_.handle != 0); + return comgr_obj_; + } + + private: + comgr_T comgr_obj_{0}; +}; + +typedef ComgrUniqueHandle ComgrDataSetUniqueHandle; +typedef ComgrUniqueHandle ComgrActionInfoUniqueHandle; +typedef ComgrUniqueHandle ComgrDataUniqueHandle; + +} // namespace comgr_helper + namespace helpers { bool UnbundleBitCode(const std::vector& bundled_bit_code, const std::string& isa, size_t& co_offset, size_t& co_size); -bool addCodeObjData(amd_comgr_data_set_t& input, const std::vector& source, +bool addCodeObjData(comgr_helper::ComgrDataSetUniqueHandle& input, const std::vector& source, const std::string& name, const amd_comgr_data_kind_t type); -bool extractBuildLog(amd_comgr_data_set_t dataSet, std::string& buildLog); -bool extractByteCodeBinary(const amd_comgr_data_set_t inDataSet, +bool extractBuildLog(comgr_helper::ComgrDataSetUniqueHandle& dataSet, std::string& buildLog); +bool extractByteCodeBinary(const comgr_helper::ComgrDataSetUniqueHandle& inDataSet, const amd_comgr_data_kind_t dataKind, std::vector& bin); -bool createAction(amd_comgr_action_info_t& action, std::vector& options, - const std::string& isa, +bool createAction(comgr_helper::ComgrActionInfoUniqueHandle& action, + std::vector& options, const std::string& isa, const amd_comgr_language_t lang = AMD_COMGR_LANGUAGE_NONE); -bool compileToExecutable(const amd_comgr_data_set_t compileInputs, const std::string& isa, - std::vector& compileOptions, +bool compileToExecutable(const comgr_helper::ComgrDataSetUniqueHandle& compileInputs, + const std::string& isa, std::vector& compileOptions, std::vector& linkOptions, std::string& buildLog, std::vector& exe); -bool compileToBitCode(const amd_comgr_data_set_t compileInputs, const std::string& isa, - std::vector& compileOptions, std::string& buildLog, - std::vector& LLVMBitcode); -bool linkLLVMBitcode(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& linkOptions, std::string& buildLog, - std::vector& LinkedLLVMBitcode); -bool createExecutable(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& exeOptions, std::string& buildLog, - std::vector& executable, bool spirv_bc = false); -bool convertSPIRVToLLVMBC(const amd_comgr_data_set_t linkInputs, const std::string& isa, - std::vector& linkOptions, std::string& buildLog, - std::vector& linkedSPIRVBitcode); +bool compileToBitCode(const comgr_helper::ComgrDataSetUniqueHandle& compileInputs, + const std::string& isa, std::vector& compileOptions, + std::string& buildLog, std::vector& LLVMBitcode); +bool linkLLVMBitcode(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& linkOptions, + std::string& buildLog, std::vector& LinkedLLVMBitcode); +bool createExecutable(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& exeOptions, + std::string& buildLog, std::vector& executable, bool spirv_bc = false); +bool convertSPIRVToLLVMBC(const comgr_helper::ComgrDataSetUniqueHandle& linkInputs, + const std::string& isa, std::vector& linkOptions, + std::string& buildLog, std::vector& linkedSPIRVBitcode); bool demangleName(const std::string& mangledName, std::string& demangledName); std::string handleMangledName(std::string loweredName); bool fillMangledNames(std::vector& executable, @@ -84,45 +149,45 @@ bool IsCompatibleWithGenericTarget(const std::string& coTarget, const std::strin * HIPRTC linker options */ struct LinkArguments { - uint64_t max_registers_ = 0; ///< Maximum registers that a thread may a use - uint64_t threads_per_block_ = 0; ///< Minimum No. of threads per block - float wall_time_ = 0.0f; ///< Value for total wall clock time - char* info_log_ = nullptr; ///< Pointer to a buffer to print log information - uint64_t info_log_size_ = 0; ///< Size of the buffer in bytes for logged info - char* error_log_ = nullptr; ///< Pointer to a buffer to print log errors - uint64_t error_log_size_ = 0; ///< Size of the buffer in bytes for logged errors - uint64_t optimization_level_ = 3; ///< Value of the optimization level for generated code - ///< acceptable options -O0, -O1, -O2, -O3 - uint64_t target_from_hip_context_ = 0; ///< Determines the target, based on the current context - uint64_t jit_target_= 0; ///< CUDA Only JIT target - uint64_t fallback_strategy_ = 0; ///< CUDA Only Choice of fallback strategy - uint32_t generate_debug_info_ = 0; ///< Create debug information in output -g, if set - uint64_t log_verbose_ = 0; ///< Generate verbose log messages - uint32_t generate_line_info_ = 0; ///< Generate line number information - uint64_t cache_mode_ = 0; ///< CUDA Only Enables caching explicitly - bool sm3x_opt_ = false; ///< CUDA Only New SM3X option - bool fast_compile_ = false; ///< CUDA Only Set fast compile - const char** global_symbol_names_ = nullptr; ///< Array of device symbol names to be relocated - ///< to the host - void** global_symbol_addresses_ = nullptr; ///< Array of host addresses to be relocated to the - ///< device - uint64_t global_symbol_count_ = 0; ///< Number of symbol count - int32_t lto_ = 0; ///< Enable link time optimization for device code - int32_t ftz_ = 0; ///< Set single-precision denormals - int32_t prec_div_ = 1; ///< Set single-precision floating-point division - ///< and reciprocals - int32_t prec_sqrt_ = 1; ///< Set single-precision floating-point square root - int32_t fma_ = 1; ///< Enable floating-point multiplies and - ///< adds/subtracts operations - int32_t pic_ = 0; ///< Generates Position Independent code - int32_t min_cta_per_sm_ = 0; ///< Hints to JIT compiler the minimum number of - ///< CTAs from kernel's grid to be mapped to SM - int32_t max_threads_per_block_ = 0; ///< Maximum number of threads in a thread block - int32_t override_directive_values_ = 0; ///< Override Directive values - const char** linker_ir2isa_args_ = nullptr; ///< Hip Only Linker options to be passed on - ///< to compiler - uint64_t linker_ir2isa_args_count_ = 0; ///< Hip Only Count of linker options to be passed - ///< on to compiler + uint64_t max_registers_ = 0; ///< Maximum registers that a thread may a use + uint64_t threads_per_block_ = 0; ///< Minimum No. of threads per block + float wall_time_ = 0.0f; ///< Value for total wall clock time + char* info_log_ = nullptr; ///< Pointer to a buffer to print log information + uint64_t info_log_size_ = 0; ///< Size of the buffer in bytes for logged info + char* error_log_ = nullptr; ///< Pointer to a buffer to print log errors + uint64_t error_log_size_ = 0; ///< Size of the buffer in bytes for logged errors + uint64_t optimization_level_ = 3; ///< Value of the optimization level for generated code + ///< acceptable options -O0, -O1, -O2, -O3 + uint64_t target_from_hip_context_ = 0; ///< Determines the target, based on the current context + uint64_t jit_target_ = 0; ///< CUDA Only JIT target + uint64_t fallback_strategy_ = 0; ///< CUDA Only Choice of fallback strategy + uint32_t generate_debug_info_ = 0; ///< Create debug information in output -g, if set + uint64_t log_verbose_ = 0; ///< Generate verbose log messages + uint32_t generate_line_info_ = 0; ///< Generate line number information + uint64_t cache_mode_ = 0; ///< CUDA Only Enables caching explicitly + bool sm3x_opt_ = false; ///< CUDA Only New SM3X option + bool fast_compile_ = false; ///< CUDA Only Set fast compile + const char** global_symbol_names_ = nullptr; ///< Array of device symbol names to be relocated + ///< to the host + void** global_symbol_addresses_ = nullptr; ///< Array of host addresses to be relocated to the + ///< device + uint64_t global_symbol_count_ = 0; ///< Number of symbol count + int32_t lto_ = 0; ///< Enable link time optimization for device code + int32_t ftz_ = 0; ///< Set single-precision denormals + int32_t prec_div_ = 1; ///< Set single-precision floating-point division + ///< and reciprocals + int32_t prec_sqrt_ = 1; ///< Set single-precision floating-point square root + int32_t fma_ = 1; ///< Enable floating-point multiplies and + ///< adds/subtracts operations + int32_t pic_ = 0; ///< Generates Position Independent code + int32_t min_cta_per_sm_ = 0; ///< Hints to JIT compiler the minimum number of + ///< CTAs from kernel's grid to be mapped to SM + int32_t max_threads_per_block_ = 0; ///< Maximum number of threads in a thread block + int32_t override_directive_values_ = 0; ///< Override Directive values + const char** linker_ir2isa_args_ = nullptr; ///< Hip Only Linker options to be passed on + ///< to compiler + uint64_t linker_ir2isa_args_count_ = 0; ///< Hip Only Count of linker options to be passed + ///< on to compiler }; class RTCProgram { @@ -132,7 +197,7 @@ class RTCProgram { static std::once_flag initialized_; RTCProgram(std::string name); - ~RTCProgram() { amd::Comgr::destroy_data_set(exec_input_); } + ~RTCProgram() {} // Member Functions bool findIsa(); @@ -144,7 +209,7 @@ class RTCProgram { std::string build_log_; std::vector executable_; - amd_comgr_data_set_t exec_input_; + hip::comgr_helper::ComgrDataSetUniqueHandle exec_input_; }; class LinkProgram : public RTCProgram { @@ -163,7 +228,7 @@ class LinkProgram : public RTCProgram { bool is_bundled_ = false; // Private Data Members - amd_comgr_data_set_t link_input_; + hip::comgr_helper::ComgrDataSetUniqueHandle link_input_; std::vector link_options_; static std::unordered_set linker_set_; @@ -175,7 +240,6 @@ class LinkProgram : public RTCProgram { ~LinkProgram() { amd::ScopedLock lock(lock_); linker_set_.erase(this); - amd::Comgr::destroy_data_set(link_input_); } // Public Member Functions bool AddLinkerOptions(unsigned int num_options, hipJitOption* options_ptr, diff --git a/projects/clr/hipamd/src/hip_fatbin.cpp b/projects/clr/hipamd/src/hip_fatbin.cpp index 9df386c173..5d14637131 100644 --- a/projects/clr/hipamd/src/hip_fatbin.cpp +++ b/projects/clr/hipamd/src/hip_fatbin.cpp @@ -28,69 +28,13 @@ THE SOFTWARE. #include "hip_platform.hpp" #include "comgrctx.hpp" #include "amd_hsa_elf.hpp" +#include "hip_comgr_helper.hpp" + namespace hip { -namespace comgr_helper { - -template class ComgrUniqueHandle { - public: - ComgrUniqueHandle() = default; - // constructor which takes ownership of a correctly initialzed handle - ComgrUniqueHandle(comgr_T& handle) : comgr_obj_(handle) { handle = {0}; }; - - template || - std::is_same_v, - bool> = true> - [[nodiscard]] amd_comgr_status_t Create() { - if constexpr (std::is_same_v) { - return amd::Comgr::create_data_set(&comgr_obj_); - } else if constexpr (std::is_same_v) { - return amd::Comgr::create_action_info(&comgr_obj_); - } - - // Unreachable code - return AMD_COMGR_STATUS_SUCCESS; - } - - template , bool> = true> - [[nodiscard]] amd_comgr_status_t Create(amd_comgr_data_kind_t kind) { - return amd::Comgr::create_data(kind, &comgr_obj_); - } - - ~ComgrUniqueHandle() { - if (comgr_obj_.handle != 0) { - if constexpr (std::is_same_v) { - amd::Comgr::destroy_data_set(comgr_obj_); - } else if constexpr (std::is_same_v) { - amd::Comgr::destroy_action_info(comgr_obj_); - } else if constexpr (std::is_same_v) { - amd::Comgr::release_data(comgr_obj_); - } - } - } - - // Delete all copy and move operators - ComgrUniqueHandle(ComgrUniqueHandle&) = delete; - ComgrUniqueHandle(ComgrUniqueHandle&&) = delete; - ComgrUniqueHandle& operator=(ComgrUniqueHandle&) = delete; - ComgrUniqueHandle& operator=(ComgrUniqueHandle&&) = delete; - - // Method to access data - comgr_T get() const { - assert(comgr_obj_.handle != 0); - return comgr_obj_; - } - - private: - comgr_T comgr_obj_{0}; -}; - - -typedef ComgrUniqueHandle ComgrDataSetUniqueHandle; -typedef ComgrUniqueHandle ComgrActionInfoUniqueHandle; -typedef ComgrUniqueHandle ComgrDataUniqueHandle; - -} // namespace comgr_helper +// Use ComgrUniqueHandle and type aliases from hip_comgr_helper.hpp +using comgr_helper::ComgrDataSetUniqueHandle; +using comgr_helper::ComgrActionInfoUniqueHandle; +using comgr_helper::ComgrDataUniqueHandle; FatBinaryInfo::FatBinaryInfo(const char* fname, const void* image) : foffset_(0), image_(image), image_mapped_(false), uri_(std::string()) { diff --git a/projects/clr/hipamd/src/hiprtc/hiprtcInternal.cpp b/projects/clr/hipamd/src/hiprtc/hiprtcInternal.cpp index b8bf210cc8..8f93c89aac 100644 --- a/projects/clr/hipamd/src/hiprtc/hiprtcInternal.cpp +++ b/projects/clr/hipamd/src/hiprtc/hiprtcInternal.cpp @@ -37,8 +37,8 @@ namespace hiprtc { // RTC Compile Program Member Functions RTCCompileProgram::RTCCompileProgram(std::string name_) : hip::RTCProgram(name_), fgpu_rdc_(false) { - if ((amd::Comgr::create_data_set(&compile_input_) != AMD_COMGR_STATUS_SUCCESS) || - (amd::Comgr::create_data_set(&link_input_) != AMD_COMGR_STATUS_SUCCESS)) { + if ((compile_input_.Create() != AMD_COMGR_STATUS_SUCCESS) || + (link_input_.Create() != AMD_COMGR_STATUS_SUCCESS)) { crashWithMessage("Failed to allocate internal hiprtc structure"); } // Add internal header diff --git a/projects/clr/hipamd/src/hiprtc/hiprtcInternal.hpp b/projects/clr/hipamd/src/hiprtc/hiprtcInternal.hpp index 79879c8ec0..063d265bd3 100644 --- a/projects/clr/hipamd/src/hiprtc/hiprtcInternal.hpp +++ b/projects/clr/hipamd/src/hiprtc/hiprtcInternal.hpp @@ -121,8 +121,8 @@ class RTCCompileProgram : public hip::RTCProgram { std::vector compile_options_; std::vector link_options_; - amd_comgr_data_set_t compile_input_; - amd_comgr_data_set_t link_input_; + hip::comgr_helper::ComgrDataSetUniqueHandle compile_input_; + hip::comgr_helper::ComgrDataSetUniqueHandle link_input_; bool fgpu_rdc_; std::vector LLVMBitcode_; @@ -141,10 +141,7 @@ class RTCCompileProgram : public hip::RTCProgram { public: RTCCompileProgram(std::string); - ~RTCCompileProgram() { - amd::Comgr::destroy_data_set(compile_input_); - amd::Comgr::destroy_data_set(link_input_); - } + ~RTCCompileProgram() {} // Converters inline static hiprtcProgram as_hiprtcProgram(RTCCompileProgram* p) {