Fix clangtidy warnings

Signed-off-by: Soren Soe <2106410+stsoe@users.noreply.github.com>

Author: stsoe

src/runtime_src/core/common/api/xrt_kernel.cpp

@@ -3492,36 +3492,36 @@ class run_impl_debug : public RunImplType
   void
   set_arg_value(const argument& arg, const arg_range<uint8_t>& value) override
   {
-    run_impl::set_arg_value(arg, value);
+    RunImplType::set_arg_value(arg, value);
     XRT_REPLAY_CAPTURE(run_set_arg_at_index, this, arg.index(), value.data_as_span());
   }
 
   void
   set_arg_value(const argument& arg, const xrt::bo& bo) override
   {
-    run_impl::set_arg_value(arg, bo);
+    RunImplType::set_arg_value(arg, bo);
     XRT_REPLAY_CAPTURE(run_set_arg_at_index, this, arg.index(), bo);
   }
 
   void
   start() override
   {
-    run_impl::start();
+    RunImplType::start();
     XRT_REPLAY_CAPTURE(run_start, this);
   }
 
   std::cv_status
   wait_throw_on_error(const std::chrono::milliseconds& timeout_ms) const override
   {
-    auto status = run_impl::wait_throw_on_error(timeout_ms);
+    auto status = RunImplType::wait_throw_on_error(timeout_ms);
     XRT_REPLAY_CAPTURE(run_wait, this); // TODO: revisit for timeout
     return status;
   }
 
   ert_cmd_state
   wait(const std::chrono::milliseconds& timeout_ms) const override
   {
-    auto state = run_impl::wait(timeout_ms);
+    auto state = RunImplType::wait(timeout_ms);
     XRT_REPLAY_CAPTURE(run_wait, this);
     return state;
 

src/runtime_src/core/common/runner/capture.cpp

@@ -9,6 +9,7 @@
 
 #include "core/common/config_reader.h"
 #include "core/common/debug.h"
+#include "core/common/error.h"
 #include "core/common/api/bo_int.h"
 #include "core/common/api/elf_int.h"
 #include "core/common/api/hw_context_int.h"
@@ -53,7 +54,7 @@ insert_json_object(json& dest, const json& src)
 static uint64_t
 to_uint64(span<const uint8_t> data)
 {
-  if (data.size() > 8)
+  if (data.size() > sizeof(uint64_t))
     throw std::runtime_error("Wrong data size");
 
   uint64_t value = 0;
@@ -114,6 +115,7 @@ class frames
     }
 
   public:
+    explicit
     bo(xrt::bo bo)
       : m_bo{std::move(bo)}
       , m_id{get_uid()}
@@ -208,6 +210,7 @@ class frames
     }
 
   public:
+    explicit
     run(const xrt::run_impl* hdl)
       : m_hdl{hdl}
       , m_run{xrt_core::kernel_int::get_run_from_impl(m_hdl)}
@@ -314,6 +317,7 @@ class frames
     const xrt::runlist_impl* m_hdl;
     std::vector<const run*> m_runs;
   public:
+    explicit
     runlist(const xrt::runlist_impl* hdl)
       : m_hdl{hdl}
     {}
@@ -414,8 +418,11 @@ class frames
               v->set_run(run);
             }
           }
-          else if constexpr (std::is_same_v<T, uint64_t>)
-            args.push_back(v);
+          else if constexpr (std::is_same_v<T, uint64_t>) {
+            // gcc14 comple error requires explicit help here
+            // args.push_back(v); // fails RHEL10 (gcc14)
+            args.emplace_back(arg_type{v});
+          }
         }, rarg);
       }
       XRT_DEBUGF("<- capture_frame_start(run:0x%x)\n", run);
@@ -532,7 +539,13 @@ class frames
 
   ~frames()
   {
-    save_replay_script();
+    try {
+      save_replay_script();
+    }
+    catch (const std::exception& ex) {
+      xrt_core::send_exception_message("could not save replay script: " + std::string(ex.what()));
+    }
+      
   }
 
   std::string

src/runtime_src/core/common/runner/detail/capture_artifacts.h

@@ -48,15 +48,16 @@ class artifacts
   static uint64_t
   calculate_hash(span<const char> data)
   {
-    auto hash = 0xcbf29ce484222325ULL;
+    auto hash = 0xcbf29ce484222325ULL; // NOLINT
     for (unsigned char c : data) {
       hash ^= c;
-      hash *= 0x100000001b3ULL;
+      hash *= 0x100000001b3ULL; // NOLINT
     }
     return hash;
   }
 
 public:
+  explicit
   artifacts(std::filesystem::path dir)
     : m_dir(init_dir(std::move(dir)))
   {}
@@ -78,7 +79,7 @@ class artifacts
     if (!ostr)
       throw std::runtime_error("Failed to open file for capture dump: " + file_path.string());
 
-    ostr.write(data.data(), data.size());
+    ostr.write(data.data(), static_cast<std::streamsize>(data.size()));
     if (!ostr)
       throw std::runtime_error("Error writing capture dump to: " + file_path.string());
 

src/runtime_src/core/common/runner/detail/module_cache.h

@@ -11,9 +11,7 @@
 #include <map>
 #include <string>
 
-namespace xrt_core::detail {
-
-namespace module_cache {
+namespace xrt_core::detail::module_cache {
 
 using repo_type = xrt_core::artifacts::repository;
 
@@ -22,7 +20,7 @@ using repo_type = xrt_core::artifacts::repository;
 static std::map<std::string, xrt::elf> s_path2elf; // NOLINT
 static std::map<xrt::elf, xrt::module> s_elf2mod;  // NOLINT
 
-static xrt::module
+xrt::module
 get(const xrt::elf& elf)
 {
   if (auto it = s_elf2mod.find(elf); it != s_elf2mod.end())
@@ -33,7 +31,7 @@ get(const xrt::elf& elf)
   return mod;
 }
 
-static xrt::module
+xrt::module
 get(const std::string& path, const repo_type& repo)
 {
   //auto key = repo->get_id() + path; // must be unique to repo
@@ -51,8 +49,6 @@ get(const std::string& path, const repo_type& repo)
   return get(elf);
 }
 
-} // module_cache
-
-} // xrt_core::runner::detail
+} // xrt_core::runner::detail::module_cache
 
 #endif

src/runtime_src/core/common/runner/detail/streambuf.h

@@ -49,13 +49,13 @@ struct streambuf : public std::streambuf
     else if (way == std::ios_base::beg)
       new_gptr = eback() + off;
     else
-      return std::streampos(std::streamoff(-1));
+      return {std::streamoff(-1)};
 
     if (new_gptr < eback() || new_gptr > egptr())
-      return std::streampos(std::streamoff(-1));
+      return {std::streamoff(-1)};
 
     setg(eback(), new_gptr, egptr());
-    return std::streampos(new_gptr - eback());
+    return {new_gptr - eback()};
   }
 };
 

src/runtime_src/core/common/runner/replay.cpp

@@ -153,7 +153,7 @@ struct replayer
       auto read_cfg = [&](const json& cfg_object) {
         xrt::hw_context::cfg_type cfg;
         for (auto [key, value] : cfg_object.items())
-          cfg.emplace(std::move(key), value.get<std::string>());
+          cfg.emplace(key, value.get<std::string>());
 
         return cfg;
       };
@@ -181,12 +181,12 @@ struct replayer
     {
         auto instance = kernel_object.at("instance").get<std::string>(); // required
         auto elf = kernel_object.value<std::string>("ctrlcode", ""); // optional elf file
-        if (elf.empty())
+        if (elf.empty()) {
           // Legacy kernel (alveo) or elf file was used when the hwctx was constructed
           return xrt::kernel{xrt_core::hw_context_int::get_elf_flow(hwctx)
                              ? xrt::ext::kernel{hwctx, instance}
                              : xrt::kernel{hwctx, instance}};
-
+        }
 
         // With ctrlcode ELF, the flow is legacy xclbin. The kernel
         // must be in the xclbin.