diff --git a/0013-AArch64-Adapt-to-ai4c_onnxrunner.patch b/0013-AArch64-Adapt-to-ai4c_onnxrunner.patch new file mode 100644 index 0000000000000000000000000000000000000000..f8d711eb5f4a114367a861d29c7e152c82c94e7f --- /dev/null +++ b/0013-AArch64-Adapt-to-ai4c_onnxrunner.patch @@ -0,0 +1,140 @@ +From bf71c96ed790ae7d0d5c85e22f6c3fc09fd949e4 Mon Sep 17 00:00:00 2001 +From: zengxianghuai +Date: Mon, 28 Apr 2025 20:28:45 +0800 +Subject: [PATCH] update DataReader.h + +--- + bolt/include/bolt/Profile/DataReader.h | 83 ++++++++++++++++---------- + 1 file changed, 53 insertions(+), 30 deletions(-) + +diff --git a/bolt/include/bolt/Profile/DataReader.h b/bolt/include/bolt/Profile/DataReader.h +index bf732d47c..9c35c78a2 100644 +--- a/bolt/include/bolt/Profile/DataReader.h ++++ b/bolt/include/bolt/Profile/DataReader.h +@@ -46,12 +46,13 @@ inline raw_ostream &operator<<(raw_ostream &OS, const LBREntry &LBR) { + } + + extern "C" { +-typedef void *(*CreateONNXRunnerFunc)(const char *); +-typedef void (*DeleteONNXRunnerFunc)(void *); +-typedef std::vector (*RunONNXModelFunc)(void *, +- const std::vector &, +- const std::vector &, +- const std::vector &, int); ++typedef void (*CreateONNXRunnerFunc)(const char*); ++typedef void (*addInt64InputFunc)(int64_t*, int); ++typedef int (*inferenceFunc)(); ++typedef void (*clearEngineFunc)(); ++typedef void (*freeEngineFunc)(); ++typedef float *(*getProbabilityFunc)(int, int); ++typedef void (*freeProbabilityFunc)(float*); + } + + struct Location { +@@ -295,32 +296,33 @@ public: + + ~DataReader() { + // delete onnxrunner; +- if (onnxRunner && libHandle && handleOnnxRuntime) { +- DeleteONNXRunnerFunc deleteONNXRunner = +- (DeleteONNXRunnerFunc)dlsym(libHandle, "deleteONNXRunner"); +- deleteONNXRunner(onnxRunner); ++ if (libHandle) { ++ freeEngineFunc freeEngine = ++ (freeEngineFunc)dlsym(libHandle, "free_engine"); ++ if (!freeEngine) { ++ outs() << "error: llvm-bolt failed during loading free_engine.\n"; ++ exit(1); ++ } ++ freeEngine(); + dlclose(libHandle); +- dlclose(handleOnnxRuntime); + } + } + + /// Initialize the onnxruntime model. + void initializeONNXRunner(const std::string &modelPath) { +- if (!onnxRunner && !libHandle && !handleOnnxRuntime) { +- handleOnnxRuntime = +- dlopen("libonnxruntime.so", RTLD_LAZY | RTLD_GLOBAL); +- if (handleOnnxRuntime == nullptr) { +- outs() << "error: llvm-bolt failed during loading onnxruntime.so.\n"; ++ if (!libHandle) { ++ libHandle = dlopen("ai4c_onnxrunner.so", RTLD_LAZY); ++ if (!libHandle) { ++ outs() << "error: llvm-bolt failed during loading ai4c_onnxrunner.so.\n"; + exit(1); + } +- libHandle = dlopen("libONNXRunner.so", RTLD_LAZY); +- if (libHandle == nullptr) { +- outs() << "error: llvm-bolt failed during loading libONNXRunner.so.\n"; ++ initEngineFunc initialize = ++ (initEngineFunc)dlsym(libHandle, "initialize"); ++ if (!initialize) { ++ outs() << "error: llvm-bolt failed during loading initialize.\n"; + exit(1); + } +- CreateONNXRunnerFunc createONNXRunner = +- (CreateONNXRunnerFunc)dlsym(libHandle, "createONNXRunner"); +- onnxRunner = createONNXRunner(modelPath.c_str()); ++ initialize(modelPath.c_str()); + } + } + +@@ -328,16 +330,37 @@ public: + float ONNXInference(const std::vector &input_string, + const std::vector &input_int64, + const std::vector &input_float, int batch_size = 1) { +- if (onnxRunner && libHandle) { +- RunONNXModelFunc runONNXModel = +- (RunONNXModelFunc)dlsym(libHandle, "runONNXModel"); +- std::vector model_preds = runONNXModel( +- onnxRunner, input_string, input_int64, input_float, batch_size); +- if (model_preds.size() <= 0) { ++ if (libHandle) { ++ addInt64InputFunc addInt64Input = ++ (addInt64InputFunc)dlsym(libHandle, "add_int64_input"); ++ inferenceFunc inference = (inferenceFunc)dlsym(libHandle, "inference"); ++ getProbabilityFunc getProbability = ++ (getProbabilityFunc)dlsym(libHandle, "get_label_probability"); ++ freeProbabilityFunc freeProbability = ++ (freeProbabilityFunc)dlsym(libHandle, "free_label_probability"); ++ clearEngineFunc clearEngine = ++ (clearEngineFunc)dlsym(libHandle, "clear_engine"); ++ ++ if (!addInt64Input || !inference || !getProbability || !freeProbability || ++ !clearEngine) { ++ outs() << "error: llvm-bolt failed during loading ai4c_onnxrunner.so.\n"; ++ exit(1); ++ } ++ ++ std::vector modelInput(input_int64.begin(), input_int64.end()); ++ addInt64Input(modelInput.data(), modelInput.size()); ++ inference(); ++ ++ // output tensors: {label, label_prob}, label_prob=sequence> ++ float* preds = getProbability(1, 1); ++ if (preds == nullptr) { + outs() << "error: llvm-bolt model prediction result cannot be empty.\n"; + exit(1); + } +- float pred = model_preds[0]; ++ ++ float pred = preds[0]; ++ freeProbability(preds); ++ clearEngine(); + return pred; + } + return -1.0; +@@ -356,7 +379,7 @@ protected: + void *libHandle; + + /// The library handle of the onnxruntime. +- void *handleOnnxRuntime; ++ /// void *handleOnnxRuntime; + + /// The annotating threshold for the model prediction. + float threshold; +-- +2.33.0 + diff --git a/llvm-bolt.spec b/llvm-bolt.spec index 6945cfc9c0ff051073b16b8aa08d06a0323e98d2..a001b2adf4c38eef6da63fe18a9b0cd2a6766849 100644 --- a/llvm-bolt.spec +++ b/llvm-bolt.spec @@ -27,7 +27,7 @@ Name: %{pkg_name} Version: %{bolt_version} -Release: 6 +Release: 7 Summary: BOLT is a post-link optimizer developed to speed up large applications License: Apache-2.0 URL: https://github.com/llvm/llvm-project/tree/main/bolt @@ -47,6 +47,7 @@ Patch9: 0009-support-aarch64-instrumentation.patch Patch10: 0010-AArch64-Add-hybrid-guess-approach-for-edge-weight-estimation.patch Patch11: 0011-support-D-FOT-addrs-data-parsing-for-optimized-binary.patch Patch12: 0012-Add-Om-for-Kunpeng-Opts.patch +Patch13: 0013-AArch64-Adapt-to-ai4c_onnxrunner.patch BuildRequires: gcc BuildRequires: gcc-c++ @@ -160,6 +161,9 @@ rm -f %{buildroot}/%{_builddir}/%{bolt_srcdir}/%{__cmake_builddir}/%{_lib}/lib*. %doc %{install_docdir} %changelog +* Tue Apr 28 2025 zengxianghuai 17.0.6-7 +- adapt to ai4c_onnxrunner.so + * Fri Apr 25 2025 rfwang07 17.0.6-6 - Type:backport - ID:NA