address review comments

- Refactored ptrace_runner to hide the class used

Author: meserve-amd

projects/rocprofiler-sdk/source/lib/rocprofiler-sdk-rocattach/CMakeLists.txt

@@ -33,8 +33,9 @@ endforeach()
 
 target_sources(
     rocprofiler-sdk-rocattach-shared-library
-    PRIVATE rocattach.cpp auxv.cpp ptrace_runner.cpp ptrace_session.cpp symbol_lookup.cpp
-            common/ptrace.cpp)
+    PRIVATE rocattach.cpp auxv.cpp ptrace_runner.cpp ptrace_session.cpp symbol_lookup.cpp)
+add_subdirectory(common)
+
 target_include_directories(
     rocprofiler-sdk-rocattach-shared-library
     INTERFACE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/source/include>

projects/rocprofiler-sdk/source/lib/rocprofiler-sdk-rocattach/common/CMakeLists.txt

@@ -0,0 +1,23 @@
+# MIT License
+#
+# Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+target_sources(rocprofiler-sdk-rocattach-shared-library PRIVATE ptrace.cpp)

projects/rocprofiler-sdk/source/lib/rocprofiler-sdk-rocattach/common/wait_for_atomic.hpp

@@ -24,52 +24,59 @@
 
 #include <atomic>
 #include <chrono>
+#include <functional>
 #include <thread>
+#include <type_traits>
 
 namespace rocprofiler
 {
 namespace rocattach
 {
-template <typename T>
+// Blocks until predicate(flag) == true or timeout_ms milliseconds have elapsed.
+// Returns true if predicate(flag) was true
+// Returns false if timeout occurred
+template <typename Tp, typename PredicateT>
 bool
-wait_for(std::atomic<T>& flag, T condition, size_t timeout_ms, bool equal)
+wait_for(std::atomic<Tp>& flag, size_t timeout_ms, PredicateT&& predicate)
 {
-    auto cond_check = [&]() {
-        if(equal) return flag.load() == condition;
-        return flag.load() != condition;
-    };
+    static_assert(std::is_invocable<PredicateT, std::atomic<Tp>&>::value, "Invalid predicate");
+    using predicate_return_type = typename std::invoke_result<PredicateT, std::atomic<Tp>&>::type;
+    static_assert(std::is_same<predicate_return_type, bool>::value,
+                  "Predicate must return boolean");
+
     auto start_time       = std::chrono::steady_clock::now();
     auto timeout_duration = std::chrono::milliseconds(timeout_ms);
     auto end_time         = start_time + timeout_duration;
     while(std::chrono::steady_clock::now() < end_time)
     {
-        if(cond_check())
+        if(std::invoke(std::forward<PredicateT>(predicate), std::forward<std::atomic<Tp>&>(flag)))
         {
             return true;
         }
         std::this_thread::yield();
     }
     // Last chance check in case we were scheduled after timeout
-    return cond_check();
+    return std::invoke(std::forward<PredicateT>(predicate), std::forward<std::atomic<Tp>&>(flag));
 }
-// Blocks until flag is NOT equal to condition or timeout_ms milliseconds have elapsed.
+// Blocks until flag is NOT equal to value or timeout_ms milliseconds have elapsed.
 // Returns true if the flag is not equal
 // Returns false if timeout occurred
 template <typename T>
 bool
-wait_for_ne(std::atomic<T>& flag, T condition, size_t timeout_ms)
+wait_for_ne(std::atomic<T>& flag, T value, size_t timeout_ms)
 {
-    return wait_for(flag, condition, timeout_ms, false);
+    auto predicate = [value](std::atomic<T>& a) { return a.load() != value; };
+    return wait_for(flag, timeout_ms, predicate);
 }
-// Blocks until flag is equal to condition or timeout_ms milliseconds have elapsed.
+// Blocks until flag is equal to value or timeout_ms milliseconds have elapsed.
 // Returns true if the flag is equal
 // Returns false if timeout occurred
 template <typename T>
 bool
-wait_for_eq(std::atomic<T>& flag, T condition, size_t timeout_ms)
+wait_for_eq(std::atomic<T>& flag, T value, size_t timeout_ms)
 {
-    return wait_for(flag, condition, timeout_ms, true);
+    auto predicate = [value](std::atomic<T>& a) { return a.load() == value; };
+    return wait_for(flag, timeout_ms, predicate);
 }
-
 }  // namespace rocattach
 }  // namespace rocprofiler