Counter API and Samples Updates (#410)

* Update include/rocprofiler-sdk/{counters,profile_config}.h - use rocprofiler_agent_id_t instead of rocprofiler_agent_t * Update samples - use rocprofiler-sdk::rocprofiler-sdk instead of rocprofiler::rocprofiler in cmake - api_callback_tracing sample roctxProfiler{Pause,Resume} - api_callback_tracing sample uses ROCTx - updates to use rocprofiler_agent_id_t * Update run-ci.py - exclude rocprofiler-sdk-tool from samples (no sample uses that code) * Update lib/rocprofiler-sdk-tool/tool.cpp - Update rocprofiler_iterate_agent_supported_counters to use agent ID * Update lib/rocprofiler-sdk/counters/core.* - profile_config has pointer to agent instead of copy * Update lib/rocprofiler-sdk/agent.* - provide get_agent(...) func via rocp agent id * Update lib/rocprofiler-sdk/{buffer,callback}_tracing.cpp - return ROCPROFILER_STATUS_ERROR_NOT_IMPLEMENTED for enums missing implementation * Update lib/rocprofiler-sdk/counters.cpp - update to use rocprofiler_agent_id_t instead of rocprofiler_agent_t * Update lib/rocprofiler-sdk/profile_config.cpp - update to use rocprofiler_agent_id_t instead of rocprofiler_agent_t * Update source/docs - requirements.txt + install reqs in cmake * Bump version to 0.1.0 * Update samples/api_callback_tracing/CMakeLists.txt - LD_LIBRARY_PATH for test * Update test/rocprofv3/tracing/CMakeLists.txt - reorder validation files so memory copy comes first * Update lib/rocprofiler-sdk-tool/tool.cpp - logging for flushing buffers - variables for buffer_size and buffer_watermark - increase the watermark to a full buffer - use dedicated threads for each buffer * Update lib/rocprofiler-sdk-tool/CMakeLists.txt - test sets ROCPROF_LOG_LEVEL and ROCPROFILER_LOG_LEVEL to info * Remove lib/rocprofiler-sdk-tool/trace_buffer.hpp * Update lib/rocprofiler-sdk-tool/CMakeLists.txt - drop log level to warning when leak sanitizer is enabled (produces small memory leak)
2024-01-25 23:47:40 -06:00
commit 9a8b6f6b7b
@@ -31,7 +31,7 @@ add_library(buffered-api-tracing-client SHARED)
 target_sources(buffered-api-tracing-client PRIVATE client.cpp client.hpp)
 target_link_libraries(
    buffered-api-tracing-client
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-build-flags
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-build-flags
            rocprofiler::samples-common-library)

 set_source_files_properties(main.cpp PROPERTIES LANGUAGE HIP)
@@ -31,28 +31,30 @@ add_library(callback-api-tracing-client SHARED)
 target_sources(callback-api-tracing-client PRIVATE client.cpp client.hpp)
 target_link_libraries(
    callback-api-tracing-client
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-build-flags
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-build-flags
            rocprofiler::samples-common-library)

 set_source_files_properties(main.cpp PROPERTIES LANGUAGE HIP)
+
 find_package(Threads REQUIRED)
+find_package(rocprofiler-sdk-roctx REQUIRED)

 add_executable(callback-api-tracing)
 target_sources(callback-api-tracing PRIVATE main.cpp)
 target_link_libraries(
-    callback-api-tracing PRIVATE callback-api-tracing-client Threads::Threads
-                                 rocprofiler::samples-build-flags)
+    callback-api-tracing
+    PRIVATE callback-api-tracing-client Threads::Threads
+            rocprofiler-sdk-roctx::rocprofiler-sdk-roctx rocprofiler::samples-build-flags)

 add_test(NAME callback-api-tracing COMMAND $<TARGET_FILE:callback-api-tracing>)

+set(callback-api-tracing-env
+    ${ROCPROFILER_MEMCHECK_PRELOAD_ENV}
+    "HSA_TOOLS_LIB=$<TARGET_FILE:rocprofiler::rocprofiler-shared-library>"
+    "LD_LIBRARY_PATH=$<TARGET_FILE_DIR:rocprofiler-sdk-roctx::rocprofiler-sdk-roctx-shared-library>:$ENV{LD_LIBRARY_PATH}"
+    )
+
 set_tests_properties(
    callback-api-tracing
-    PROPERTIES
-        TIMEOUT
-        45
-        LABELS
-        "samples"
-        ENVIRONMENT
-        "${ROCPROFILER_MEMCHECK_PRELOAD_ENV};HSA_TOOLS_LIB=$<TARGET_FILE:rocprofiler::rocprofiler-shared-library>"
-        FAIL_REGULAR_EXPRESSION
-        "threw an exception")
+    PROPERTIES TIMEOUT 45 LABELS "samples" ENVIRONMENT "${callback-api-tracing-env}"
+               FAIL_REGULAR_EXPRESSION "threw an exception")
@@ -33,6 +33,9 @@

 #include "client.hpp"

+#include <rocprofiler-sdk/context.h>
+#include <rocprofiler-sdk/fwd.h>
+#include <rocprofiler-sdk/marker/api_id.h>
 #include <rocprofiler-sdk/registration.h>
 #include <rocprofiler-sdk/rocprofiler.h>

@@ -54,6 +57,7 @@
 #include <ratio>
 #include <string>
 #include <string_view>
+#include <unordered_set>
 #include <vector>
 namespace client
 {
@@ -129,6 +133,11 @@ print_call_stack(const call_stack_t& _call_stack)
 callback_name_info
 get_callback_id_names()
 {
+    static auto supported = std::unordered_set<rocprofiler_callback_tracing_kind_t>{
+        ROCPROFILER_CALLBACK_TRACING_HSA_API,
+        ROCPROFILER_CALLBACK_TRACING_HIP_API,
+        ROCPROFILER_CALLBACK_TRACING_MARKER_API};
+
    auto cb_name_info = callback_name_info{};
    //
    // callback for each kind operation
@@ -137,8 +146,7 @@ get_callback_id_names()
        [](rocprofiler_callback_tracing_kind_t kindv, uint32_t operation, void* data_v) {
            auto* name_info_v = static_cast<callback_name_info*>(data_v);

-            if(kindv == ROCPROFILER_CALLBACK_TRACING_HSA_API ||
-               kindv == ROCPROFILER_CALLBACK_TRACING_HIP_API)
+            if(supported.count(kindv) > 0)
            {
                const char* name = nullptr;
                ROCPROFILER_CALL(rocprofiler_query_callback_tracing_kind_operation_name(
@@ -160,8 +168,7 @@ get_callback_id_names()
                         "query callback tracing kind operation name");
        if(name) name_info_v->kind_names[kind] = name;

-        if(kind == ROCPROFILER_CALLBACK_TRACING_HSA_API ||
-           kind == ROCPROFILER_CALLBACK_TRACING_HIP_API)
+        if(supported.count(kind) > 0)
        {
            ROCPROFILER_CALL(rocprofiler_iterate_callback_tracing_kind_operations(
                                 kind, tracing_kind_operation_cb, static_cast<void*>(data)),
@@ -177,6 +184,27 @@ get_callback_id_names()
    return cb_name_info;
 }

+void
+tool_tracing_ctrl_callback(rocprofiler_callback_tracing_record_t record,
+                           rocprofiler_user_data_t*,
+                           void* client_data)
+{
+    auto* ctx = static_cast<rocprofiler_context_id_t*>(client_data);
+
+    if(record.phase == ROCPROFILER_CALLBACK_PHASE_ENTER &&
+       record.kind == ROCPROFILER_CALLBACK_TRACING_MARKER_API &&
+       record.operation == ROCPROFILER_MARKER_API_ID_roctxProfilerPause)
+    {
+        ROCPROFILER_CALL(rocprofiler_stop_context(*ctx), "pausing client context");
+    }
+    else if(record.phase == ROCPROFILER_CALLBACK_PHASE_EXIT &&
+            record.kind == ROCPROFILER_CALLBACK_TRACING_MARKER_API &&
+            record.operation == ROCPROFILER_MARKER_API_ID_roctxProfilerResume)
+    {
+        ROCPROFILER_CALL(rocprofiler_start_context(*ctx), "resuming client context");
+    }
+}
+
 void
 tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
                      rocprofiler_user_data_t*              user_data,
@@ -226,6 +254,58 @@ tool_tracing_callback(rocprofiler_callback_tracing_record_t record,
    _mutex.unlock();
 }

+std::vector<uint32_t>
+tool_control_init(rocprofiler_context_id_t& primary_ctx)
+{
+    struct RoctxOperations
+    {
+        std::vector<uint32_t> core  = {};
+        std::vector<uint32_t> cntrl = {};
+    };
+
+    auto roctx_ops = RoctxOperations();
+
+    // get all the operations for ROCPROFILER_CALLBACK_TRACING_MARKER_API and
+    // separate them into two arrays; one which contains the pause/resume operations
+    // and one with everything else
+    ROCPROFILER_CALL(
+        rocprofiler_iterate_callback_tracing_kind_operations(
+            ROCPROFILER_CALLBACK_TRACING_MARKER_API,
+            [](rocprofiler_callback_tracing_kind_t, uint32_t operation_v, void* data_v) {
+                auto* roctx_ops_v = static_cast<RoctxOperations*>(data_v);
+                if(operation_v == ROCPROFILER_MARKER_API_ID_roctxProfilerPause ||
+                   operation_v == ROCPROFILER_MARKER_API_ID_roctxProfilerResume)
+                    roctx_ops_v->cntrl.emplace_back(operation_v);
+                else
+                    roctx_ops_v->core.emplace_back(operation_v);
+                return 0;
+            },
+            &roctx_ops),
+        "iterating callback tracing kind operations");
+
+    // Create a specialized (throw-away) context for handling ROCTx profiler pause and resume.
+    // A separate context is used because if the context that is associated with roctxProfilerPause
+    // disabled that same context, a call to roctxProfilerResume would be ignored because the
+    // context that enables the callback for that API call is disabled.
+    auto cntrl_ctx = rocprofiler_context_id_t{};
+    ROCPROFILER_CALL(rocprofiler_create_context(&cntrl_ctx), "control context creation failed");
+
+    // enable callback marker tracing with only the pause/resume operations
+    ROCPROFILER_CALL(
+        rocprofiler_configure_callback_tracing_service(cntrl_ctx,
+                                                       ROCPROFILER_CALLBACK_TRACING_MARKER_API,
+                                                       roctx_ops.cntrl.data(),
+                                                       roctx_ops.cntrl.size(),
+                                                       tool_tracing_ctrl_callback,
+                                                       &primary_ctx),
+        "callback tracing service failed to configure");
+
+    // start the context so that it is always active
+    ROCPROFILER_CALL(rocprofiler_start_context(cntrl_ctx), "start of control context");
+
+    return roctx_ops.core;
+}
+
 int
 tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
 {
@@ -263,6 +343,9 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)

    ROCPROFILER_CALL(rocprofiler_create_context(&client_ctx), "context creation failed");

+    // enable the control
+    auto roctx_ops = tool_control_init(client_ctx);
+
    ROCPROFILER_CALL(
        rocprofiler_configure_callback_tracing_service(client_ctx,
                                                       ROCPROFILER_CALLBACK_TRACING_HSA_API,
@@ -281,6 +364,15 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
                                                       tool_data),
        "callback tracing service failed to configure");

+    ROCPROFILER_CALL(
+        rocprofiler_configure_callback_tracing_service(client_ctx,
+                                                       ROCPROFILER_CALLBACK_TRACING_MARKER_API,
+                                                       roctx_ops.data(),
+                                                       roctx_ops.size(),
+                                                       tool_tracing_callback,
+                                                       tool_data),
+        "callback tracing service failed to configure");
+
    int valid_ctx = 0;
    ROCPROFILER_CALL(rocprofiler_context_is_valid(client_ctx, &valid_ctx),
                     "failure checking context validity");
@@ -22,7 +22,8 @@

 #include "client.hpp"

-#include "hip/hip_runtime.h"
+#include <hip/hip_runtime.h>
+#include <rocprofiler-sdk-roctx/roctx.h>

 #include <chrono>
 #include <cstdio>
@@ -65,7 +66,7 @@ verify(int* in, int* out, int M, int N);
 }  // namespace

 __global__ void
-transpose_a(int* in, int* out, int M, int N);
+transpose_a(const int* in, int* out, int M, int N);

 void
 run(int rank, int tid, hipStream_t stream, int argc, char** argv);
@@ -76,6 +77,8 @@ main(int argc, char** argv)
    client::setup();  // currently does nothing
    // client::start(); // currently will fail

+    auto range_id = roctxRangeStart("main");
+
    int rank = 0;
    for(int i = 1; i < argc; ++i)
    {
@@ -114,18 +117,34 @@ main(int argc, char** argv)
    {
        std::vector<std::thread> _threads{};
        std::vector<hipStream_t> _streams(nthreads);
+        roctxMark("stream creation");
        for(size_t i = 0; i < nthreads; ++i)
            HIP_API_CALL(hipStreamCreate(&_streams.at(i)));
+        roctxMark("thread creation");
        for(size_t i = 1; i < nthreads; ++i)
            _threads.emplace_back(run, rank, i, _streams.at(i), argc, argv);
        run(rank, 0, _streams.at(0), argc, argv);
+        roctxMark("thread sync");
        for(auto& itr : _threads)
            itr.join();
+        roctxMark("stream destroy");
        for(size_t i = 0; i < nthreads; ++i)
            HIP_API_CALL(hipStreamDestroy(_streams.at(i)));
    }
+
    HIP_API_CALL(hipDeviceSynchronize());
+
+    auto tid = roctx_thread_id_t{};
+    // get the thread id recognized by rocprofiler-sdk from roctx
+    roctxGetThreadId(&tid);
+    // pause API tracing
+    roctxProfilerPause(tid);
+    // would not expect below to show up in profiler (depends on tool)
    HIP_API_CALL(hipDeviceReset());
+    // resume API tracing
+    roctxProfilerResume(tid);
+
+    roctxRangeStop(range_id);

    client::stop();
    client::shutdown();
@@ -134,7 +153,7 @@ main(int argc, char** argv)
 }

 __global__ void
-transpose_a(int* in, int* out, int M, int N)
+transpose_a(const int* in, int* out, int M, int N)
 {
    __shared__ int tile[shared_mem_tile_dim][shared_mem_tile_dim];

@@ -148,6 +167,10 @@ transpose_a(int* in, int* out, int M, int N)
 void
 run(int rank, int tid, hipStream_t stream, int argc, char** argv)
 {
+    auto run_name = std::stringstream{};
+    run_name << __FUNCTION__ << "(" << rank << ", " << tid << ")";
+    roctxRangePush(run_name.str().c_str());
+
    unsigned int M = 4960 * 2;
    unsigned int N = 4960 * 2;
    if(argc > 2) nitr = atoll(argv[2]);
@@ -157,8 +180,9 @@ run(int rank, int tid, hipStream_t stream, int argc, char** argv)
    std::cout << "[" << rank << "][" << tid << "] M: " << M << " N: " << N << std::endl;
    _lk.unlock();

-    std::default_random_engine         _engine{std::random_device{}() * (rank + 1) * (tid + 1)};
-    std::uniform_int_distribution<int> _dist{0, 1000};
+    auto _seed   = std::random_device{}() * (rank + 1) * (tid + 1);
+    auto _engine = std::default_random_engine{_seed};
+    auto _dist   = std::uniform_int_distribution<int>{0, 1000};

    size_t size       = sizeof(int) * M * N;
    int*   inp_matrix = new int[size];
@@ -210,6 +234,8 @@ run(int rank, int tid, hipStream_t stream, int argc, char** argv)

    delete[] inp_matrix;
    delete[] out_matrix;
+
+    roctxRangePop();
 }

 namespace
@@ -31,7 +31,7 @@ add_library(code-object-tracing-client SHARED)
 target_sources(code-object-tracing-client PRIVATE client.cpp)
 target_link_libraries(
    code-object-tracing-client
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-build-flags
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-build-flags
            rocprofiler::samples-common-library)

 set_source_files_properties(main.cpp PROPERTIES LANGUAGE HIP)
@@ -32,7 +32,7 @@ target_sources(counter-collection-buffer-client PRIVATE client.cpp client.hpp)
 target_link_libraries(
    counter-collection-buffer-client
    PUBLIC rocprofiler::samples-build-flags
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-common-library)
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-common-library)

 set_source_files_properties(main.cpp PROPERTIES LANGUAGE HIP)
 add_executable(counter-collection-buffer)
@@ -60,7 +60,7 @@ target_sources(counter-collection-functional-counter-client
 target_link_libraries(
    counter-collection-functional-counter-client
    PUBLIC rocprofiler::samples-build-flags
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-common-library)
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-common-library)

 add_executable(counter-collection-print-functional-counters)
 target_sources(counter-collection-print-functional-counters PRIVATE main.cpp)
@@ -157,20 +157,22 @@ dispatch_callback(rocprofiler_queue_id_t /*queue_id*/,
    std::vector<rocprofiler_counter_id_t> gpu_counters;

    // Iterate through the agents and get the counters available on that agent
-    ROCPROFILER_CALL(
-        rocprofiler_iterate_agent_supported_counters(
-            *agent,
-            [](rocprofiler_counter_id_t* counters, size_t num_counters, void* user_data) {
-                std::vector<rocprofiler_counter_id_t>* vec =
-                    static_cast<std::vector<rocprofiler_counter_id_t>*>(user_data);
-                for(size_t i = 0; i < num_counters; i++)
-                {
-                    vec->push_back(counters[i]);
-                }
-                return ROCPROFILER_STATUS_SUCCESS;
-            },
-            static_cast<void*>(&gpu_counters)),
-        "Could not fetch supported counters");
+    ROCPROFILER_CALL(rocprofiler_iterate_agent_supported_counters(
+                         agent->id,
+                         [](rocprofiler_agent_id_t,
+                            rocprofiler_counter_id_t* counters,
+                            size_t                    num_counters,
+                            void*                     user_data) {
+                             std::vector<rocprofiler_counter_id_t>* vec =
+                                 static_cast<std::vector<rocprofiler_counter_id_t>*>(user_data);
+                             for(size_t i = 0; i < num_counters; i++)
+                             {
+                                 vec->push_back(counters[i]);
+                             }
+                             return ROCPROFILER_STATUS_SUCCESS;
+                         },
+                         static_cast<void*>(&gpu_counters)),
+                     "Could not fetch supported counters");

    std::vector<rocprofiler_counter_id_t> collect_counters;
    // Look for the counters contained in counters_to_collect in gpu_counters
@@ -190,7 +192,7 @@ dispatch_callback(rocprofiler_queue_id_t /*queue_id*/,
    // Create a colleciton profile for the counters
    rocprofiler_profile_config_id_t profile;
    ROCPROFILER_CALL(rocprofiler_create_profile_config(
-                         *agent, collect_counters.data(), collect_counters.size(), &profile),
+                         agent->id, collect_counters.data(), collect_counters.size(), &profile),
                     "Could not construct profile cfg");

    profile_cache.emplace(agent->id.handle, profile);
@@ -127,25 +127,27 @@ dispatch_callback(rocprofiler_queue_id_t /*queue_id*/,
    if(cap.expected.empty())
    {
        std::vector<rocprofiler_counter_id_t> counters_needed;
-        ROCPROFILER_CALL(
-            rocprofiler_iterate_agent_supported_counters(
-                *agent,
-                [](rocprofiler_counter_id_t* counters, size_t num_counters, void* user_data) {
-                    std::vector<rocprofiler_counter_id_t>* vec =
-                        static_cast<std::vector<rocprofiler_counter_id_t>*>(user_data);
-                    for(size_t i = 0; i < num_counters; i++)
-                    {
-                        vec->push_back(counters[i]);
-                    }
-                    return ROCPROFILER_STATUS_SUCCESS;
-                },
-                static_cast<void*>(&counters_needed)),
-            "Could not fetch supported counters");
+        ROCPROFILER_CALL(rocprofiler_iterate_agent_supported_counters(
+                             agent->id,
+                             [](rocprofiler_agent_id_t,
+                                rocprofiler_counter_id_t* counters,
+                                size_t                    num_counters,
+                                void*                     user_data) {
+                                 std::vector<rocprofiler_counter_id_t>* vec =
+                                     static_cast<std::vector<rocprofiler_counter_id_t>*>(user_data);
+                                 for(size_t i = 0; i < num_counters; i++)
+                                 {
+                                     vec->push_back(counters[i]);
+                                 }
+                                 return ROCPROFILER_STATUS_SUCCESS;
+                             },
+                             static_cast<void*>(&counters_needed)),
+                         "Could not fetch supported counters");

        for(auto& found_counter : counters_needed)
        {
            size_t expected = 0;
-            rocprofiler_query_counter_instance_count(*agent, found_counter, &expected);
+            rocprofiler_query_counter_instance_count(agent->id, found_counter, &expected);
            cap.remaining.push_back(found_counter);
            cap.expected.emplace(found_counter.handle, expected);
            const char* name;
@@ -165,7 +167,7 @@ dispatch_callback(rocprofiler_queue_id_t /*queue_id*/,

    // Select the next counter to collect.
    ROCPROFILER_CALL(
-        rocprofiler_create_profile_config(*agent, &(cap.remaining.back()), 1, &profile),
+        rocprofiler_create_profile_config(agent->id, &(cap.remaining.back()), 1, &profile),
        "Could not construct profile cfg");

    cap.remaining.pop_back();
@@ -31,7 +31,7 @@ add_library(intercept-table-client SHARED)
 target_sources(intercept-table-client PRIVATE client.cpp client.hpp)
 target_link_libraries(
    intercept-table-client
-    PRIVATE rocprofiler::rocprofiler rocprofiler::samples-build-flags
+    PRIVATE rocprofiler-sdk::rocprofiler-sdk rocprofiler::samples-build-flags
            rocprofiler::samples-common-library)

 set_source_files_properties(main.cpp PROPERTIES LANGUAGE HIP)
@@ -282,9 +282,10 @@ rocprofiler_configure(uint32_t                 version,
    client_tool_data->emplace_back(
        client::source_location{__FUNCTION__, __FILE__, __LINE__, info.str()});

-    rocprofiler_at_runtime_api_registration(client::api_registration_callback,
-                                            ROCPROFILER_HSA_LIBRARY,
-                                            static_cast<void*>(client_tool_data));
+    ROCPROFILER_CALL(rocprofiler_at_runtime_api_registration(client::api_registration_callback,
+                                                             ROCPROFILER_HSA_LIBRARY,
+                                                             static_cast<void*>(client_tool_data)),
+                     "runtime api registration");

    // create configure data
    static auto cfg =