Gbaraldi/threadtrace2 (#724)

* Added first ATT API * Finalizing thread trace API * Fixing more rebase conflicts * Added codeobj disassembly sample * Fixing merge issues with rebase [2] * Adding ATT packets * Implemented thread trace intercept * Moved codeobj parser to same repo as rocprofiler * Moved thread trace to new API * Fixing merge conflicts * Fixing more merge conflicts * Adding thread trace packet reuse * Merged aql_profile_v2 headers * Linked ATT sample to aqlprofile * Updated decoder to include non-loaded codeobjs * Implemented ISA decoder into ATT sample * Added marker_id to vaddr * Updating aql_profile_v2 API to memcpy * Updating thread trace API to include 64bit markers. Using the result of ISA matching. * Added instruction type and cycles summary * Updated sample with selection of kernel by kernel_object * Added option to copy from memory kernels * Moved tool_data in thread_trace to dynamic alloc * Restoring hsa.cpp * Fixed ATT sample crash. General improvements. * Moved codeobj library to outside src/ * Updated license header * Moved codeobj_capture to camelcase * Solving some more merge conflicts * Update samples/advanced_thread_trace/CMakeLists.txt Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * Update samples/advanced_thread_trace/CMakeLists.txt Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * Update samples/code_object_isa_decode/CMakeLists.txt Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * Update source/lib/rocprofiler-sdk/thread_trace/CMakeLists.txt * Removing unused parameter check * Adding const to isEmpty * Removing unused warning * Adding libdw-dev to requirements * Running clang-format * Commenting out new aql calls * Clang format * Unused variable fix * Adding codeobj-decoder coverage * Commenting out threadtrace * Update samples/CMakeLists.txt Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * P * WOverloaded * Addressing clang-tidy * Virtual destructor on ttracer class * Corr id * Fixing code source format * Update CMakeLists.txt * Build fixes * Update source/lib/rocprofiler-sdk-codeobj/code_object_track.cpp Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * Fix shadowing * Update CMakeLists.txt * Update samples/CMakeLists.txt Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Ammar ELWazir <ammar.elwazir@amd.com> Co-authored-by: Ammar ELWazir <aelwazir@amd.com> Co-authored-by: Benjamin Welton <bewelton@amd.com> [ROCm/rocprofiler-sdk commit: 69b8a43dc6]
2024-04-08 16:43:02 -03:00
parent b501f25ba0
commit 2cd198a7e7
48 changed files with 4649 additions and 109 deletions
@@ -0,0 +1,6 @@
+set(ROCPROFILER_LIB_THREAD_TRACE_SOURCES att_core.cpp att_service.cpp)
+set(ROCPROFILER_LIB_THREAD_TRACE_HEADERS att_core.hpp)
+target_sources(rocprofiler-object-library PRIVATE ${ROCPROFILER_LIB_THREAD_TRACE_SOURCES}
+                                                  ${ROCPROFILER_LIB_THREAD_TRACE_HEADERS})
+
+# if(ROCPROFILER_BUILD_TESTS) add_subdirectory(tests) endif()
@@ -0,0 +1,238 @@
+// MIT License
+//
+// Copyright (c) 2024 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.
+
+#include <rocprofiler-sdk/fwd.h>
+#include <rocprofiler-sdk/intercept_table.h>
+#include <rocprofiler-sdk/rocprofiler.h>
+
+#include "lib/common/container/stable_vector.hpp"
+#include "lib/common/utility.hpp"
+#include "lib/rocprofiler-sdk/buffer.hpp"
+#include "lib/rocprofiler-sdk/context/context.hpp"
+#include "lib/rocprofiler-sdk/hsa/queue_controller.hpp"
+#include "lib/rocprofiler-sdk/internal_threading.hpp"
+#include "lib/rocprofiler-sdk/registration.hpp"
+
+#include <hsa/hsa_api_trace.h>
+
+#include <atomic>
+#include <cstdint>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#define CHECK_HSA(fn, message)                                                                     \
+    {                                                                                              \
+        auto _status = (fn);                                                                       \
+        if(_status != HSA_STATUS_SUCCESS)                                                          \
+        {                                                                                          \
+            LOG(ERROR) << "HSA Err: " << _status << '\n';                                          \
+            throw std::runtime_error(message);                                                     \
+        }                                                                                          \
+    }
+
+namespace rocprofiler
+{
+using AQLPacketOwner = std::unique_ptr<hsa::AQLPacket>;
+using inst_pkt_t     = common::container::small_vector<std::pair<AQLPacketOwner, int64_t>, 4>;
+using corr_id_map_t  = hsa::Queue::queue_info_session_t::external_corr_id_map_t;
+
+struct cbdata_t
+{
+    void*                                  tool_userdata;
+    rocprofiler_att_shader_data_callback_t cb_fn;
+    std::vector<uint8_t>*                  memory_space;
+};
+
+/**
+ * Callback we get from HSA interceptor when a kernel packet is being enqueued.
+ * We return an AQLPacket containing the start/stop/read packets for injection.
+ */
+AQLPacketOwner
+pre_kernel_call(ThreadTracer&                  tracer,
+                const hsa::Queue&              queue,
+                const hsa::rocprofiler_packet& kern_pkt,
+                uint64_t                       kernel_id,
+                const corr_id_map_t&           extern_corr_ids,
+                const context::correlation_id* corr_id)
+{
+    (void) extern_corr_ids;
+    (void) corr_id;
+
+    rocprofiler_correlation_id_t temp_corr_id;
+    temp_corr_id.internal       = 0;
+    temp_corr_id.external.value = 0;
+    temp_corr_id.external.ptr   = nullptr;
+
+    auto control_flags = tracer.params->dispatch_cb_fn(queue.get_id(),
+                                                       queue.get_agent().get_rocp_agent(),
+                                                       temp_corr_id,
+                                                       &kern_pkt.kernel_dispatch,
+                                                       kernel_id,
+                                                       tracer.params->callback_userdata);
+
+    if(control_flags == ROCPROFILER_ATT_CONTROL_NONE) return nullptr;
+
+    assert(control_flags == ROCPROFILER_ATT_CONTROL_START_AND_STOP && "Error: Not implemented");
+
+    uint64_t                    agent = queue.get_agent().get_hsa_agent().handle;
+    std::lock_guard<std::mutex> lk(tracer.trace_resources_mut);
+
+    try
+    {
+        auto moved = std::move(tracer.resources.at(agent));
+        tracer.resources.erase(agent);
+        return moved;
+    } catch(std::out_of_range& e)
+    {
+        LOG(WARNING) << "Attempt to initialize ATT without allocated resources!\n";
+        return nullptr;
+    }
+}
+
+hsa_status_t
+thread_trace_callback(uint32_t shader, void* buffer, uint64_t size, void* callback_data)
+{
+    void*                 tool_userdata = static_cast<cbdata_t*>(callback_data)->tool_userdata;
+    auto                  callback_fn   = *static_cast<cbdata_t*>(callback_data)->cb_fn;
+    std::vector<uint8_t>& cpu_data      = *static_cast<cbdata_t*>(callback_data)->memory_space;
+
+    // TODO(gbaraldi): Handle parallel callbacks
+    static std::mutex           mut;
+    std::lock_guard<std::mutex> lk(mut);
+
+    if(size > cpu_data.size()) cpu_data.resize(size + cpu_data.size());
+
+    auto status = hsa::get_queue_controller()->get_core_table().hsa_memory_copy_fn(
+        cpu_data.data(), buffer, size);
+    if(status != HSA_STATUS_SUCCESS)
+    {
+        LOG(WARNING) << "Failed to copy hsa memory!";
+        return HSA_STATUS_SUCCESS;
+    }
+
+    callback_fn(shader, 0, "", cpu_data.data(), size, tool_userdata);
+    return HSA_STATUS_SUCCESS;
+}
+
+void
+post_kernel_call(ThreadTracer& tracer, inst_pkt_t& aql)
+{
+    std::vector<uint8_t> cpu_data{};
+    auto pair = cbdata_t{tracer.params->callback_userdata, tracer.params->shader_cb_fn, &cpu_data};
+    (void) pair;
+
+    for(auto& aql_pkt : aql)
+    {
+        auto* pkt = dynamic_cast<hsa::TraceAQLPacket*>(aql_pkt.first.get());
+        if(!pkt) continue;
+
+        // auto status = aqlprofile_att_iterate_data(pkt->GetHandle(), thread_trace_callback,
+        // &pair); CHECK_HSA(status, "Failed to iterate ATT data");
+
+        std::lock_guard<std::mutex> lk(tracer.trace_resources_mut);
+        if(tracer.agent_active_queues.find(pkt->GetAgent()) != tracer.agent_active_queues.end())
+            tracer.resources[pkt->GetAgent()] = std::move(aql_pkt.first);
+    }
+}
+
+common::Synchronized<std::optional<int64_t>> client;
+
+void
+ThreadTracer::start_context()
+{
+    // Only one thread should be attempting to enable/disable this context
+    client.wlock([&](auto& client_id) {
+        if(client_id) return;
+
+        client_id = hsa::get_queue_controller()->add_callback(
+            std::nullopt,
+            [=](const hsa::Queue&                                               q,
+                const hsa::rocprofiler_packet&                                  kern_pkt,
+                uint64_t                                                        kernel_id,
+                rocprofiler_user_data_t*                                        user_data,
+                const hsa::Queue::queue_info_session_t::external_corr_id_map_t& extern_corr_ids,
+                const context::correlation_id*                                  corr_id) {
+                (void) user_data;
+                return pre_kernel_call(*this, q, kern_pkt, kernel_id, extern_corr_ids, corr_id);
+            },
+            [=](const hsa::Queue&                       q,
+                hsa::rocprofiler_packet                 kern_pkt,
+                const hsa::Queue::queue_info_session_t& session,
+                inst_pkt_t&                             aql) {
+                post_kernel_call(*this, aql);
+                (void) session;
+                (void) kern_pkt;
+                (void) q;
+            });
+    });
+}
+
+void
+ThreadTracer::stop_context()
+{
+    client.wlock([&](auto& client_id) {
+        if(!client_id) return;
+
+        // Remove our callbacks from HSA's queue controller
+        hsa::get_queue_controller()->remove_callback(*client_id);
+        client_id = std::nullopt;
+    });
+}
+
+void
+ThreadTracer::resource_init(const hsa::AgentCache& cache,
+                            const CoreApiTable&    coreapi,
+                            const AmdExtTable&     ext)
+{
+    uint64_t                    agent = cache.get_hsa_agent().handle;
+    std::lock_guard<std::mutex> lk(trace_resources_mut);
+
+    if(agent_active_queues.find(agent) != agent_active_queues.end())
+    {
+        agent_active_queues.at(agent).fetch_add(1);
+        return;
+    }
+
+    auto factory     = aql::ThreadTraceAQLPacketFactory(cache, this->params, coreapi, ext);
+    resources[agent] = factory.construct_packet();
+    agent_active_queues[agent] = 1;
+}
+
+void
+ThreadTracer::resource_deinit(const hsa::AgentCache& cache)
+{
+    uint64_t                    agent = cache.get_hsa_agent().handle;
+    std::lock_guard<std::mutex> lk(trace_resources_mut);
+
+    try
+    {
+        if(agent_active_queues.at(agent).fetch_add(-1) > 1) return;
+    } catch(std::out_of_range&)
+    {}
+
+    agent_active_queues.erase(agent);
+    resources.erase(agent);
+}
+
+}  // namespace rocprofiler
@@ -0,0 +1,75 @@
+// MIT License
+//
+// Copyright (c) 2024 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.
+
+#pragma once
+
+#include <rocprofiler-sdk/intercept_table.h>
+#include <tuple>
+#include "include/rocprofiler-sdk/thread_trace.h"
+
+namespace rocprofiler
+{
+struct thread_trace_parameters
+{
+    rocprofiler_context_id_t               context_id;
+    rocprofiler_att_dispatch_callback_t    dispatch_cb_fn;
+    rocprofiler_att_shader_data_callback_t shader_cb_fn;
+    void*                                  callback_userdata;
+
+    // Parameters
+    rocprofiler_att_parameter_flag_t flags;
+    uint64_t                         buffer_size;
+    uint8_t                          target_cu;
+    uint8_t                          simd_select;
+    uint8_t                          reserved;
+    uint8_t                          vmid_mask;
+    uint16_t                         perfcounter_mask;
+    uint8_t                          perfcounter_ctrl;
+    uint64_t                         shader_engine_mask;
+
+    // GFX9 Only
+    std::vector<std::string> perfcounters;
+};
+
+namespace hsa
+{
+class AQLPacket;
+};
+
+class ThreadTracer
+{
+public:
+    ThreadTracer(std::shared_ptr<thread_trace_parameters>& _params)
+    : params(_params){};
+    virtual void start_context();
+    virtual void stop_context();
+    virtual void resource_init(const hsa::AgentCache&, const CoreApiTable&, const AmdExtTable&);
+    virtual void resource_deinit(const hsa::AgentCache&);
+    virtual ~ThreadTracer() = default;
+
+    std::shared_ptr<thread_trace_parameters>                      params;
+    std::mutex                                                    trace_resources_mut;
+    std::unordered_map<uint64_t, std::unique_ptr<hsa::AQLPacket>> resources;
+    std::unordered_map<uint64_t, std::atomic<int>>                agent_active_queues;
+};  // namespace thread_trace
+
+}  // namespace rocprofiler
@@ -0,0 +1,81 @@
+// MIT License
+//
+// Copyright (c) 2024 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.
+
+#include <rocprofiler-sdk/rocprofiler.h>
+
+#include "lib/rocprofiler-sdk/aql/helpers.hpp"
+#include "lib/rocprofiler-sdk/context/context.hpp"
+#include "lib/rocprofiler-sdk/hsa/agent_cache.hpp"
+
+extern "C" {
+/**
+ * @brief Configure buffered dispatch profile Counting Service.
+ *        Collects the counters in dispatch packets and stores them
+ *        in buffer_id. The buffer may contain packets from more than
+ *        one dispatch (denoted by correlation id). Will trigger the
+ *        callback based on the parameters setup in buffer_id_t.
+ *
+ * @param [in] context_id context id
+ * @param [in] buffer_id id of the buffer to use for the counting service
+ * @param [in] profile profile config to use for dispatch
+ * @return ::rocprofiler_status_t
+ */
+rocprofiler_status_t ROCPROFILER_API
+rocprofiler_configure_thread_trace_service(rocprofiler_context_id_t               context_id,
+                                           rocprofiler_att_parameters_t           parameters,
+                                           rocprofiler_att_dispatch_callback_t    dispatch_callback,
+                                           rocprofiler_att_shader_data_callback_t shader_callback,
+                                           void*                                  callback_userdata)
+{
+    auto* ctx = rocprofiler::context::get_mutable_registered_context(context_id);
+    if(!ctx) return ROCPROFILER_STATUS_ERROR_CONTEXT_NOT_STARTED;
+    if(ctx->thread_trace) return ROCPROFILER_STATUS_ERROR_SERVICE_ALREADY_CONFIGURED;
+    if(parameters.flags.raw != 0) return ROCPROFILER_STATUS_ERROR_NOT_IMPLEMENTED;
+
+    auto thread_tracer = std::make_shared<rocprofiler::thread_trace_parameters>();
+
+    thread_tracer->context_id        = context_id;
+    thread_tracer->dispatch_cb_fn    = dispatch_callback;
+    thread_tracer->shader_cb_fn      = shader_callback;
+    thread_tracer->callback_userdata = callback_userdata;
+
+    thread_tracer->flags       = parameters.flags;
+    thread_tracer->buffer_size = parameters.buffer_size;
+    thread_tracer->target_cu   = parameters.target_cu;
+    thread_tracer->simd_select = parameters.simd_select;
+    thread_tracer->vmid_mask   = parameters.vmid_mask;
+
+    thread_tracer->perfcounter_mask = parameters.perfcounter_mask;
+    thread_tracer->perfcounter_ctrl = parameters.perfcounter_ctrl;
+
+    for(int i = 0; i < parameters.perfcounter_num; i++)
+        thread_tracer->perfcounters.emplace_back(parameters.perfcounter[i]);
+
+    thread_tracer->shader_engine_mask = 0;
+    for(int i = 0; i < parameters.shader_num; i++)
+        thread_tracer->shader_engine_mask |= 1ul << parameters.shader_ids[i];
+
+    ctx->thread_trace = std::make_shared<rocprofiler::ThreadTracer>(thread_tracer);
+
+    return ROCPROFILER_STATUS_SUCCESS;
+}
+}