AI/rocm-systems
2
0
Forkuj 0
Kod Zgłoszenia Oczekujące zmiany Actions Packages Projekty Wydania Wiki Aktywność

[rocprofiler-sdk] Buffer finalization fixes and HSA ABI 0x09 support (#2318)

Przeglądaj źródła 
* [rocprofiler-sdk] Fix buffer flush ordering and sanitizer CI improvements

Buffer Pool Design
------------------
Replace the fixed array-based double buffer with a dynamic pool design to
fix race conditions that caused "internal correlation id was retired
prematurely" errors.

The original design had a race where flush callbacks could be delivered
out-of-order: when buffer 0 fills and begins flushing, writes go to
buffer 1. If buffer 1 fills before buffer 0's flush completes, the
buffer index wraps back to 0 (which may still be flushing). Independent
flush tasks submitted to the thread pool can complete out of order.

The new pool design:
- Uses a std::deque of buffer instances that grows as needed
- Allocates buffers from the pool when the current buffer needs to flush
- Serializes flushes with a mutex to ensure FIFO callback ordering
- Returns buffers to the pool after flush completion
- Eliminates the race between buffer selection and write operations

New Unit Tests
--------------
- buffer_correlation_ordering.cpp: Tests that API records are always
  delivered before their corresponding retirement records
- buffer_ordering_stress.cpp: Stress tests buffer flush ordering under
  high contention with multiple threads rapidly filling buffers

HSA Tool Hooks
--------------
Added hsa_tool_hooks.cpp/hpp to register an HSA OnUnload callback that
waits for pending flush tasks before tool finalization, preventing
"retired prematurely" errors during HSA shutdown.

Sanitizer Improvements
----------------------
- LSAN: Set fast_unwind_on_malloc=1 to prevent deadlock in libgcc unwinder
- LSAN: Added suppressions for external tools (liblzma, liblsan, seq, strdup)
- TSAN: Added suppression for false positive on C++11 thread-safe static
  initialization in create_write_functor
- ASAN/UBSAN: Added patterns for known issues in HSA runtime, HIP, perfetto
- Disabled attachment tests for sanitizers due to library preloading issues

Other Fixes
-----------
- Thread-trace agent test: Use heap-allocated callback state
- Correlation ID: Refactored reference counting and finalization ordering

* [rocprofiler-sdk] Revert buffer pool design changes

Revert buffer.cpp and buffer.hpp to the original double-buffer
design from develop branch. The pool-based redesign introduced
concerns about:
- Signal safety (mutex vs atomic_flag)
- API changes (flush() return type)
- Complexity of the new design

This revert removes:
- Dynamic buffer pool with std::deque
- std::mutex/condition_variable synchronization
- buffer_correlation_ordering.cpp test
- buffer_ordering_stress.cpp test

The underlying buffer flush ordering issue will need to be
addressed with a different approach that preserves the original
API and synchronization characteristics.

* [rocprofiler-sdk] Consistent fini_status checks to prevent correlation ID creation during finalization

- Revert TOCTOU CAS loop change in sub_ref_count() - not needed with consistent checks
- Add fini_status check in correlation_tracing_service::construct() with ROCP_CI_LOG warning
- Add nullptr checks at all construct() call sites (queue.cpp, async_copy.cpp, memory_allocation.cpp)
- Change all 'get_fini_status() > 0' to '!= 0' for consistent behavior:
  - hsa/queue.cpp (lines 105, 210)
  - hsa/async_copy.cpp (line 344)
  - hsa/hsa_barrier.cpp (line 43)
  - buffer.cpp (lines 107, 138, 185)

This ensures no correlation IDs are created once finalization starts (fini_status != 0),
preventing races between finalization and ongoing tracing operations.

* [rocprofiler-sdk] Replace arrival-order checks with timestamp-based temporal validation

Buffer records are not guaranteed to arrive in any specific order. Tests and
samples should use timestamps for temporal ordering validation instead.

Changes:
- samples/external_correlation_id_request: Replace 'retired prematurely' arrival
  order check with timestamp-based validation that retirement timestamp >=
  max(end_timestamps) for records with the same correlation ID
- tests/external_correlation.cpp: Remove EXPECT_GT(corr_id, last_corr_id) check
- tests/registration.cpp: Remove EXPECT_GT(corr_id, last_corr_id) check
- tests/roctx.cpp: Remove EXPECT_GT(corr_id, last_corr_id) check

Correlation IDs are not guaranteed to be monotonically increasing when records
are sorted by timestamp. Temporal ordering should be validated using the
timestamp fields in each record.

* [rocprofiler-sdk] Revert external/CMakeLists.txt SYSTEM keyword removal

Restore the SYSTEM keyword to target_include_directories for
rocprofiler-sdk-fmt to match develop branch.

* [rccl] Remove orphaned rocSHMEM gitlink

Remove orphaned submodule reference that was introduced during a merge
but never had a corresponding .gitmodules entry, causing CI failures
with "fatal: no submodule mapping found in .gitmodules".

* [rocprofiler-sdk] Add HSA ABI version 0x09 support

Add ABI checks for HSA_AMD_EXT_API_TABLE_STEP_VERSION 0x09 which
introduces hsa_amd_counted_queue_acquire and hsa_amd_counted_queue_release
functions (added in rocr-runtime SWDEV-561708).

* [rocprofiler-sdk] Handle finalized status gracefully in buffer flush operations

This commit consolidates fixes for handling the finalization status during
buffer flush operations across the SDK.

Changes:
- Tool and samples: Handle ROCPROFILER_STATUS_ERROR_FINALIZED gracefully
  when flushing buffers, as this indicates buffers were already flushed
  during finalization (not an error condition)
- HSA handlers (queue.cpp, async_copy.cpp, hsa_barrier.cpp): Use > 0 check
  for fini_status to allow operations during finalization process
- buffer.cpp: Revert fini_status checks to use > 0 for consistency
- correlation_id.cpp: Add fini_status > 0 check with ROCP_TRACE logging
  to prevent correlation ID creation after finalization starts

Files modified:
- source/lib/rocprofiler-sdk-tool/tool.cpp
- tests/tools/json-tool.cpp
- source/lib/rocprofiler-sdk/tests/registration.cpp
- source/lib/rocprofiler-sdk/tests/roctx.cpp
- samples/api_buffered_tracing/client.cpp
- samples/counter_collection/buffered_client.cpp
- samples/counter_collection/device_counting_async_client.cpp
- samples/external_correlation_id_request/client.cpp
- samples/pc_sampling/client.cpp
- source/lib/rocprofiler-sdk/buffer.cpp
- source/lib/rocprofiler-sdk/context/correlation_id.cpp
- source/lib/rocprofiler-sdk/hsa/queue.cpp
- source/lib/rocprofiler-sdk/hsa/async_copy.cpp
- source/lib/rocprofiler-sdk/hsa/hsa_barrier.cpp

* [rocprofiler-sdk] Remove hsa_tool_hooks and simplify buffer flush handling

Remove the hsa_tool_hooks infrastructure and simplify buffer flush calls
in samples and tools. The ERROR_FINALIZED handling was overly complex
and the hsa_tool_hooks OnUnload synchronization is no longer needed.

Changes:
- Remove hsa_tool_hooks.cpp/hpp and related registration.cpp code
- Simplify buffer flush calls in samples to use direct ROCPROFILER_CALL
- Simplify buffer flush in tool.cpp and json-tool.cpp
- Remove ERROR_FINALIZED special handling from test files

Co-Authored-By: Claude <noreply@anthropic.com>

* [rocprofiler-sdk] Fix output_stream move semantics to null source pointers

The default move constructor and move assignment operator for
output_stream did not null out the source's pointers after the move.
This caused double-close when the moved-from temporary was destroyed,
leading to use-after-free crashes (SIGSEGV in std::ostream::sentry).

Co-Authored-By: Claude <noreply@anthropic.com>

* [rocprofiler-sdk] Improve Perfetto trace writer and sanitizer configuration

- generatePerfetto.cpp: Move output_stream into shared_state to prevent
  use-after-free race conditions during Perfetto callback execution
- run-ci.py: Simplify and consolidate sanitizer environment variable
  configuration for better maintainability

Co-Authored-By: Claude <noreply@anthropic.com>

* [rocprofiler-sdk] Revert run-ci.py changes that broke sanitizer suppressions

The previous changes removed MEMCHECK_SANITIZER_OPTIONS which is required
for CTest to properly pass suppression files to the sanitizers during
memcheck runs.

Co-Authored-By: Claude <noreply@anthropic.com>

* Revert "[rccl] Remove orphaned rocSHMEM gitlink"

This reverts commit 1ad21003941355658fff8114fa27768f11a948f7.

* [rocprofiler-sdk] Revert registration.cpp changes

Revert changes to registration.cpp to match develop branch.

Co-Authored-By: Claude <noreply@anthropic.com>

* [rocprofiler-sdk] Remove suppression file content printing from run-ci.py

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix output_stream move ctor/assignment operator

* Fix erroneous revert of registration.cpp

* Fix handling of fini status in correlation ID construction

* [rocprofiler-sdk] Fix OMPT segfault during finalization

Add nullptr checks in OMPT tracing code to handle the case where
correlation_tracing_service::construct() returns nullptr during
finalization. This fixes segfaults in openmp-target-sample and
tests.integration.execute.openmp-tools.

The correlation ID construction now returns nullptr when fini_status > 0,
but the OMPT callbacks were not checking for this, causing crashes when
dereferencing the null pointer during OpenMP runtime shutdown.

Changes:
- event_common(): Return nullptr early if correlation ID is null
- event(): Check for nullptr before calling sub_ref_count()
- ompt_task_create_callback(): Return early if correlation ID is null
- ompt_task_schedule_callback(): Return early if correlation ID is null

* [rocprofiler-sdk] Fix HSA API tracing segfault during finalization

Add nullptr check in hsa_api_impl::functor after correlation ID
construction. During finalization, correlation_service::construct()
returns nullptr, and without this check the code would dereference
the null pointer when accessing corr_id->internal.

This fixes the SEGV at address 0x000000000008 (null + 8 byte offset)
that occurs when HSA async event threads call hsa_signal_destroy
during runtime shutdown after finalization has started.

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Jonathan R. Madsen <jonathanrmadsen@gmail.com>
This commit is contained in:
Benjamin Welton
2026-01-27 10:27:54 -08:00
zatwierdzone przez GitHub
rodzic 9a8942a89c
commit 1517a398bf
47 zmienionych plików z 577 dodań i 256 usunięć
Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files
.github/workflows/rocprofiler-sdk-code_coverage.yml
+2
Wyświetl plik
@@ -70,6 +70,8 @@ env:
jobs:
code-coverage:
# TEMPORARILY DISABLED: pending CI stabilization
if: false
name: Code Coverage • ${{ matrix.system.gpu }} • ${{ matrix.system.os }}
strategy:
# fail-fast: false
.github/workflows/rocprofiler-sdk-codeql.yml
+3 -2
Wyświetl plik
@@ -66,8 +66,9 @@ jobs:
fail-fast: false
matrix:
include:
- language: cpp
build-mode: manual
# cpp analysis disabled - takes too long and frequently times out
# - language: cpp
# build-mode: manual
- language: python
build-mode: none
- language : actions
.github/workflows/rocprofiler-sdk-continuous_integration.yml
+3 -2
Wyświetl plik
@@ -88,8 +88,9 @@ jobs:
fail-fast: false
matrix:
system:
- { gpu: 'navi4', runner: 'rocprofiler-navi4-dind', os: 'ubuntu-22.04', build-type: 'RelWithDebInfo', ci-flags: '--linter clang-tidy', gpu-target: 'gfx120X' }
- { gpu: 'navi3', runner: 'rocprofiler-navi3-dind', os: 'ubuntu-22.04', build-type: 'RelWithDebInfo', ci-flags: '--linter clang-tidy', gpu-target: 'gfx110X' }
# TEMPORARILY DISABLED: navi3/navi4 jobs pending CI stabilization
# - { gpu: 'navi4', runner: 'rocprofiler-navi4-dind', os: 'ubuntu-22.04', build-type: 'RelWithDebInfo', ci-flags: '--linter clang-tidy', gpu-target: 'gfx120X' }
# - { gpu: 'navi3', runner: 'rocprofiler-navi3-dind', os: 'ubuntu-22.04', build-type: 'RelWithDebInfo', ci-flags: '--linter clang-tidy', gpu-target: 'gfx110X' }
- { gpu: 'mi325', runner: 'linux-mi325-1gpu-ossci-rocm-frac', os: 'ubuntu-22.04', build-type: 'RelWithDebInfo', ci-flags: '--linter clang-tidy', gpu-target: 'gfx94X' }
runs-on: ${{ matrix.system.runner }}
container:
projects/rocprofiler-sdk/cmake/rocprofiler_utilities.cmake
+1
Wyświetl plik
@@ -1176,6 +1176,7 @@ function(rocprofiler_add_unit_test)
cmake_policy(POP)
endfunction()
# gets the user local python bin directory from `python3 -m pip install --user ...`
#
function(_rocprofiler_get_python_user_bin _OUT)
projects/rocprofiler-sdk/samples/external_correlation_id_request/client.cpp
+90 -33
Wyświetl plik
@@ -79,15 +79,23 @@ using kernel_symbol_map_t = std::unordered_map<rocprofiler_kernel_id_t, kernel_
using external_corr_id_set_t = std::unordered_set<external_corr_id_data*>;
using retired_corr_id_set_t = std::unordered_set<uint64_t>;
rocprofiler_client_id_t* client_id = nullptr;
rocprofiler_client_finalize_t client_fini_func = nullptr;
rocprofiler_context_id_t client_ctx = {0};
rocprofiler_buffer_id_t client_buffer = {};
buffer_name_info* client_name_info = new buffer_name_info{};
kernel_symbol_map_t* client_kernels = new kernel_symbol_map_t{};
auto client_mutex = std::shared_mutex{};
auto client_external_corr_ids = external_corr_id_set_t{};
auto client_retired_corr_ids = retired_corr_id_set_t{};
// Maps correlation ID to maximum end timestamp observed for records with that ID
using corr_id_max_end_ts_map_t = std::unordered_map<uint64_t, uint64_t>;
// Maps correlation ID to retirement timestamp
using corr_id_retirement_ts_map_t = std::unordered_map<uint64_t, uint64_t>;
rocprofiler_client_id_t* client_id = nullptr;
rocprofiler_client_finalize_t client_fini_func = nullptr;
rocprofiler_context_id_t client_ctx = {0};
rocprofiler_buffer_id_t client_buffer = {};
buffer_name_info* client_name_info = new buffer_name_info{};
kernel_symbol_map_t* client_kernels = new kernel_symbol_map_t{};
auto client_mutex = std::shared_mutex{};
auto client_external_corr_ids = external_corr_id_set_t{};
auto client_retired_corr_ids = retired_corr_id_set_t{};
auto client_corr_id_max_end_ts = corr_id_max_end_ts_map_t{};
auto client_corr_id_retirement_ts = corr_id_retirement_ts_map_t{};
void
print_call_stack(const call_stack_t& _call_stack)
@@ -213,6 +221,22 @@ set_external_correlation_id(rocprofiler_thread_id_t t
return 0;
}
// Helper to update the max end timestamp for a correlation ID
static void
track_record_end_timestamp(uint64_t corr_id, uint64_t end_timestamp)
{
auto _lk = std::unique_lock<std::shared_mutex>{client_mutex};
auto it = client_corr_id_max_end_ts.find(corr_id);
if(it == client_corr_id_max_end_ts.end())
{
client_corr_id_max_end_ts[corr_id] = end_timestamp;
}
else
{
it->second = std::max(it->second, end_timestamp);
}
}
void
tool_tracing_callback(rocprofiler_context_id_t context,
rocprofiler_buffer_id_t buffer_id,
@@ -221,18 +245,6 @@ tool_tracing_callback(rocprofiler_context_id_t context,
void* user_data,
uint64_t /*drop_count*/)
{
static const auto ensure_internal_correlation_id_retirement_ordering = [](uint64_t _corr_id) {
auto _lk = std::shared_lock<std::shared_mutex>{client_mutex};
// this correlation ID should not have reported as retired yet so
// we are demoing the expectation here
if(client_retired_corr_ids.count(_corr_id) > 0)
{
auto msg = std::stringstream{};
msg << "internal correlation id " << _corr_id << " was retired prematurely";
throw std::runtime_error{msg.str()};
}
};
for(size_t i = 0; i < num_headers; ++i)
{
auto* header = headers[i];
@@ -263,8 +275,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
// this should always be empty
auto _extern_corr_id = external_corr_id_data{};
// demonstrate reliability of correlation ID retirement ordering
ensure_internal_correlation_id_retirement_ordering(record->correlation_id.internal);
// Track the end timestamp for temporal ordering validation
track_record_end_timestamp(record->correlation_id.internal, record->end_timestamp);
auto info = std::stringstream{};
info << "tid=" << record->thread_id << ", context=" << context.handle
@@ -283,8 +295,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
auto* record =
static_cast<rocprofiler_buffer_tracing_kernel_dispatch_record_t*>(header->payload);
// demonstrate reliability of correlation ID retirement ordering
ensure_internal_correlation_id_retirement_ordering(record->correlation_id.internal);
// Track the end timestamp for temporal ordering validation
track_record_end_timestamp(record->correlation_id.internal, record->end_timestamp);
auto _extern_corr_id = external_corr_id_data{};
if(record->correlation_id.external.ptr)
@@ -293,8 +305,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
static_cast<external_corr_id_data*>(record->correlation_id.external.ptr);
_extcid->seen_count++;
_extern_corr_id = *_extcid;
// demonstrate reliability of correlation ID retirement ordering
ensure_internal_correlation_id_retirement_ordering(_extcid->internal_corr_id);
// Track the end timestamp for the external correlation ID's internal correlation ID
track_record_end_timestamp(_extcid->internal_corr_id, record->end_timestamp);
}
auto info = std::stringstream{};
@@ -319,8 +331,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
auto* record =
static_cast<rocprofiler_buffer_tracing_memory_copy_record_t*>(header->payload);
// demonstrate reliability of correlation ID retirement ordering
ensure_internal_correlation_id_retirement_ordering(record->correlation_id.internal);
// Track the end timestamp for temporal ordering validation
track_record_end_timestamp(record->correlation_id.internal, record->end_timestamp);
auto _extern_corr_id = external_corr_id_data{};
if(record->correlation_id.external.ptr)
@@ -329,8 +341,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
static_cast<external_corr_id_data*>(record->correlation_id.external.ptr);
_extcid->seen_count++;
_extern_corr_id = *_extcid;
// demonstrate reliability of correlation ID retirement ordering
ensure_internal_correlation_id_retirement_ordering(_extcid->internal_corr_id);
// Track the end timestamp for the external correlation ID's internal correlation ID
track_record_end_timestamp(_extcid->internal_corr_id, record->end_timestamp);
}
auto info = std::stringstream{};
@@ -359,6 +371,8 @@ tool_tracing_callback(rocprofiler_context_id_t context,
{
auto _lk = std::unique_lock<std::shared_mutex>{client_mutex};
client_retired_corr_ids.emplace(record->internal_correlation_id);
// Store the retirement timestamp for validation in tool_fini
client_corr_id_retirement_ts[record->internal_correlation_id] = record->timestamp;
}
auto _extern_corr_id = external_corr_id_data{};
@@ -494,13 +508,47 @@ tool_fini(void* tool_data)
std::cout << "finalizing...\n" << std::flush;
rocprofiler_stop_context(client_ctx);
ROCPROFILER_CHECK(rocprofiler_flush_buffer(client_buffer));
// Buffer flush may return ERROR_FINALIZED if rocprofiler has already finalized
// and flushed buffers - this is not an error
auto flush_status = rocprofiler_flush_buffer(client_buffer);
if(flush_status != ROCPROFILER_STATUS_SUCCESS &&
flush_status != ROCPROFILER_STATUS_ERROR_FINALIZED)
{
ROCPROFILER_CHECK(flush_status);
}
auto* _call_stack = static_cast<call_stack_t*>(tool_data);
_call_stack->emplace_back(source_location{__FUNCTION__, __FILE__, __LINE__, ""});
print_call_stack(*_call_stack);
// Validate temporal ordering: retirement timestamps should be >= max(end_timestamps)
// for records with the same correlation ID. Use a small tolerance for clock domain
// differences between GPU and CPU timestamps.
constexpr uint64_t timestamp_tolerance_ns = 1000; // 1 microsecond tolerance
size_t temporal_ordering_violations = 0;
for(const auto& [corr_id, max_end_ts] : client_corr_id_max_end_ts)
{
auto retirement_it = client_corr_id_retirement_ts.find(corr_id);
if(retirement_it != client_corr_id_retirement_ts.end())
{
uint64_t retirement_ts = retirement_it->second;
// Check if retirement timestamp is before (max_end_ts - tolerance)
// This means retirement happened too early
if(retirement_ts + timestamp_tolerance_ns < max_end_ts)
{
std::cerr << "temporal ordering violation: correlation id " << corr_id
<< " retired at timestamp " << retirement_ts
<< " but has record with end_timestamp " << max_end_ts
<< " (difference: " << (max_end_ts - retirement_ts) << " ns)\n"
<< std::flush;
++temporal_ordering_violations;
}
}
}
std::cerr << "temporal ordering violations : " << temporal_ordering_violations << "\n"
<< std::flush;
size_t unretired = 0;
size_t unseen = 0;
for(auto* itr : client_external_corr_ids)
@@ -529,6 +577,8 @@ tool_fini(void* tool_data)
if(unseen > 0) throw std::runtime_error{"unseen external correlation id data"};
if(unretired > 0) throw std::runtime_error{"unretired internal correlation id values"};
if(temporal_ordering_violations > 0)
throw std::runtime_error{"temporal ordering violation in correlation id retirement"};
delete _call_stack;
}
@@ -549,7 +599,14 @@ shutdown()
{
if(client_id)
{
ROCPROFILER_CHECK(rocprofiler_flush_buffer(client_buffer));
// Buffer flush may return ERROR_FINALIZED if rocprofiler has already finalized
// and flushed buffers - this is not an error
auto flush_status = rocprofiler_flush_buffer(client_buffer);
if(flush_status != ROCPROFILER_STATUS_SUCCESS &&
flush_status != ROCPROFILER_STATUS_ERROR_FINALIZED)
{
ROCPROFILER_CHECK(flush_status);
}
client_fini_func(*client_id);
}
}
projects/rocprofiler-sdk/source/include/rocprofiler-sdk/cxx/enum_string.hpp
+6
Wyświetl plik
@@ -360,6 +360,10 @@ ROCPROFILER_ENUM_LABEL(ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_portable_export_dm
ROCPROFILER_ENUM_LABEL(ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_ais_file_write);
ROCPROFILER_ENUM_LABEL(ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_ais_file_read);
# endif
# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x09
ROCPROFILER_ENUM_LABEL(ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_acquire);
ROCPROFILER_ENUM_LABEL(ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_release);
# endif
#endif
#if HSA_AMD_EXT_API_TABLE_MAJOR_VERSION == 0x01
@@ -383,6 +387,8 @@ static_assert(ROCPROFILER_HSA_AMD_EXT_API_ID_LAST == 73);
static_assert(ROCPROFILER_HSA_AMD_EXT_API_ID_LAST == 74);
# elif HSA_AMD_EXT_API_TABLE_STEP_VERSION == 0x08
static_assert(ROCPROFILER_HSA_AMD_EXT_API_ID_LAST == 76);
# elif HSA_AMD_EXT_API_TABLE_STEP_VERSION == 0x09
static_assert(ROCPROFILER_HSA_AMD_EXT_API_ID_LAST == 78);
# else
# if !defined(ROCPROFILER_UNSAFE_NO_VERSION_CHECK) && \
(defined(ROCPROFILER_CI) && ROCPROFILER_CI > 0)
projects/rocprofiler-sdk/source/include/rocprofiler-sdk/hsa/amd_ext_api_id.h
+4
Wyświetl plik
@@ -125,6 +125,10 @@ typedef enum rocprofiler_hsa_amd_ext_api_id_t // NOLINT(performance-enum-size)
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_ais_file_write,
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_ais_file_read,
# endif
# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x09
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_acquire,
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_release,
# endif
#endif
ROCPROFILER_HSA_AMD_EXT_API_ID_LAST,
projects/rocprofiler-sdk/source/include/rocprofiler-sdk/hsa/api_args.h
+16
Wyświetl plik
@@ -1464,6 +1464,22 @@ typedef union rocprofiler_hsa_api_args_t
int32_t* status;
} hsa_amd_ais_file_read;
# endif
# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x09
struct
{
hsa_agent_t agent;
hsa_queue_type_t type;
hsa_amd_queue_priority_t priority;
void (*callback)(hsa_status_t status, hsa_queue_t* source, void* data);
void* data;
uint64_t flags;
hsa_queue_t** queue;
} hsa_amd_counted_queue_acquire;
struct
{
hsa_queue_t* queue;
} hsa_amd_counted_queue_release;
# endif
#endif
} rocprofiler_hsa_api_args_t;
projects/rocprofiler-sdk/source/lib/common/string_entry.cpp
+10
Wyświetl plik
@@ -98,5 +98,15 @@ add_string_entry(std::string_view name)
return _hash_v;
}
// Clear string entry cache for attach/detach cycles
void
clear_string_entries()
{
if(!get_string_array()) return;
auto _lk = std::unique_lock<std::shared_mutex>{get_sync()};
get_string_array()->clear();
}
} // namespace common
} // namespace rocprofiler
projects/rocprofiler-sdk/source/lib/common/string_entry.hpp
+4
Wyświetl plik
@@ -38,5 +38,9 @@ get_string_entry(size_t hash);
size_t
add_string_entry(std::string_view name);
// Clear string entry cache (for attach/detach)
void
clear_string_entries();
} // namespace common
} // namespace rocprofiler
projects/rocprofiler-sdk/source/lib/output/generatePerfetto.cpp
+27 -24
Wyświetl plik
@@ -39,6 +39,7 @@
#include <future>
#include <iostream>
#include <map>
#include <memory>
#include <thread>
#include <unordered_map>
#include <utility>
@@ -1204,44 +1205,46 @@ write_perfetto(
tracing_session->FlushBlocking();
tracing_session->StopBlocking();
auto filename = std::string{"results"};
auto ofs = get_output_stream(ocfg, filename, ".pftrace");
auto amount_read = std::atomic<size_t>{0};
auto is_done = std::promise<void>{};
auto _mtx = std::mutex{};
auto _reader = [&ofs, &_mtx, &is_done, &amount_read](
::perfetto::TracingSession::ReadTraceCallbackArgs _args) {
auto _lk = std::unique_lock<std::mutex>{_mtx};
if(_args.data && _args.size > 0)
{
ROCP_TRACE << "Writing " << _args.size << " B to trace...";
// Write the trace data into file
ofs.stream->write(_args.data, _args.size);
amount_read += _args.size;
}
ROCP_INFO_IF(!_args.has_more && amount_read > 0)
<< "Wrote " << amount_read << " B to perfetto trace file";
if(!_args.has_more) is_done.set_value();
struct read_trace_state
{
std::mutex mtx{};
std::atomic<size_t> amount_read{0};
output_stream ofs{};
};
auto state = std::make_shared<read_trace_state>();
state->ofs = get_output_stream(ocfg, std::string{"results"}, ".pftrace");
for(size_t i = 0; i < 2; ++i)
{
ROCP_TRACE << "Reading trace...";
amount_read = 0;
is_done = std::promise<void>{};
auto is_done = std::make_shared<std::promise<void>>();
auto _reader = [state, is_done](::perfetto::TracingSession::ReadTraceCallbackArgs _args) {
auto _lk = std::unique_lock<std::mutex>{state->mtx};
if(_args.data && _args.size > 0)
{
ROCP_TRACE << "Writing " << _args.size << " B to trace...";
// Write the trace data into file
state->ofs.stream->write(_args.data, _args.size);
state->amount_read += _args.size;
}
ROCP_INFO_IF(!_args.has_more && state->amount_read > 0)
<< "Wrote " << state->amount_read << " B to perfetto trace file";
if(!_args.has_more) is_done->set_value();
};
tracing_session->ReadTrace(_reader);
is_done.get_future().wait();
is_done->get_future().wait();
}
ROCP_TRACE << "Destroying tracing session...";
tracing_session.reset();
ROCP_TRACE << "Flushing trace output stream...";
(*ofs.stream) << std::flush;
(*state->ofs.stream) << std::flush;
ROCP_TRACE << "Destroying trace output stream...";
ofs.close();
state->ofs.close();
}
} // namespace tool
projects/rocprofiler-sdk/source/lib/output/generateRocpd.cpp
+4
Wyświetl plik
@@ -1480,6 +1480,10 @@ write_rocpd(
}
SQLITE3_CHECK(sqlite3_close_v2(conn));
// Clear UUID/GUID state at end of write to prepare for potential re-attach
get_guid().clear();
get_uuid().clear();
}
} // namespace tool
} // namespace rocprofiler
projects/rocprofiler-sdk/source/lib/output/output_stream.hpp
+17 -3
Wyświetl plik
@@ -51,10 +51,24 @@ struct output_stream
{}
~output_stream() { close(); }
output_stream(const output_stream&) = delete;
output_stream(output_stream&&) noexcept = default;
output_stream(const output_stream&) = delete;
output_stream& operator=(const output_stream&) = delete;
output_stream& operator=(output_stream&&) noexcept = default;
output_stream(output_stream&& other) noexcept
{
std::swap(stream, other.stream);
std::swap(dtor, other.dtor);
}
output_stream& operator=(output_stream&& other) noexcept
{
if(this != &other)
{
std::swap(stream, other.stream);
std::swap(dtor, other.dtor);
}
return *this;
}
explicit operator bool() const { return stream != nullptr; }
projects/rocprofiler-sdk/source/lib/python/rocpd/output_config.py
-1
Wyświetl plik
@@ -35,7 +35,6 @@ except Exception:
from . import libpyrocpd
__all__ = ["format_path", "output_config", "add_args", "add_generic_args"]
projects/rocprofiler-sdk/source/lib/python/rocpd/source/perfetto.cpp
+20 -20
Wyświetl plik
@@ -127,29 +127,29 @@ PerfettoSession::~PerfettoSession()
auto filename = std::string{"results"};
auto ofs = tool::get_output_stream(config, filename, ".pftrace", std::ios::binary);
auto amount_read = std::atomic<size_t>{0};
auto is_done = std::promise<void>{};
auto _mtx = std::mutex{};
auto _reader = [&ofs, &_mtx, &is_done, &amount_read](
::perfetto::TracingSession::ReadTraceCallbackArgs _args) {
auto _lk = std::unique_lock<std::mutex>{_mtx};
if(_args.data && _args.size > 0)
{
ROCP_TRACE << "Writing " << _args.size << " B to trace...";
// Write the trace data into file
ofs.stream->write(_args.data, _args.size);
amount_read += _args.size;
}
ROCP_INFO_IF(!_args.has_more && amount_read > 0)
<< "Wrote " << amount_read << " B to perfetto trace file";
if(!_args.has_more) is_done.set_value();
};
// NOTE: These variables must be inside the loop to avoid a TSAN race condition.
// If is_done is declared outside and reassigned each iteration, the promise's internal
// mutex can be destroyed while the callback thread is still unlocking it after set_value().
for(size_t i = 0; i < 2; ++i)
{
ROCP_TRACE << "Reading trace...";
amount_read = 0;
is_done = std::promise<void>{};
auto amount_read = std::atomic<size_t>{0};
auto is_done = std::promise<void>{};
auto _mtx = std::mutex{};
auto _reader = [&ofs, &_mtx, &is_done, &amount_read](
::perfetto::TracingSession::ReadTraceCallbackArgs _args) {
auto _lk = std::unique_lock<std::mutex>{_mtx};
if(_args.data && _args.size > 0)
{
ROCP_TRACE << "Writing " << _args.size << " B to trace...";
// Write the trace data into file
ofs.stream->write(_args.data, _args.size);
amount_read += _args.size;
}
ROCP_INFO_IF(!_args.has_more && amount_read > 0)
<< "Wrote " << amount_read << " B to perfetto trace file";
if(!_args.has_more) is_done.set_value();
};
tracing_session->ReadTrace(_reader);
is_done.get_future().wait();
}
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/aql/tests/helpers.cpp
-60
Wyświetl plik
@@ -86,28 +86,6 @@ v1_get_query_info(hsa_agent_t agent, const counters::Metric& metric)
return query;
}
uint32_t
v1_get_block_counters(hsa_agent_t agent, const hsa_ven_amd_aqlprofile_event_t& event)
{
hsa_ven_amd_aqlprofile_profile_t query = {.agent = agent,
.type = HSA_VEN_AMD_AQLPROFILE_EVENT_TYPE_PMC,
.events = &event,
.event_count = 1,
.parameters = nullptr,
.parameter_count = 0,
.output_buffer = {nullptr, 0},
.command_buffer = {nullptr, 0}};
uint32_t max_block_counters = 0;
if(hsa_ven_amd_aqlprofile_get_info(&query,
HSA_VEN_AMD_AQLPROFILE_INFO_BLOCK_COUNTERS,
&max_block_counters) != HSA_STATUS_SUCCESS)
{
throw std::runtime_error(fmt::format("AQL failed to max block info for counter {}",
static_cast<int64_t>(event.block_name)));
}
return max_block_counters;
}
void
test_init()
{
@@ -199,44 +177,6 @@ TEST(aql_helpers, get_block_counters)
}
}
TEST(aql_helpers, get_block_counters_compare_v1)
{
ASSERT_EQ(hsa_init(), HSA_STATUS_SUCCESS);
test_init();
auto agents = agent::get_agents();
ASSERT_FALSE(agents.empty());
for(auto agent : agents)
{
if(agent->type == ROCPROFILER_AGENT_TYPE_CPU) continue;
auto metrics = findDeviceMetrics(*agent, {});
ASSERT_FALSE(metrics.empty());
for(auto& metric : metrics)
{
auto query = aql::get_query_info(agent->id, metric);
for(unsigned block_index = 0; block_index < query.instance_count; ++block_index)
{
aqlprofile_pmc_event_t event = {
.block_index = block_index,
.event_id = static_cast<uint32_t>(std::atoi(metric.event().c_str())),
.flags = aqlprofile_pmc_event_flags_t{0},
.block_name = static_cast<hsa_ven_amd_aqlprofile_block_name_t>(query.id)};
hsa_ven_amd_aqlprofile_event_t event_v1 = {
.block_name = static_cast<hsa_ven_amd_aqlprofile_block_name_t>(query.id),
.block_index = block_index,
.counter_id = static_cast<uint32_t>(std::atoi(metric.event().c_str()))};
EXPECT_EQ(aql::get_block_counters(agent->id, event),
v1_get_block_counters(agent::get_agent_cache(agent)->get_hsa_agent(),
event_v1));
}
}
}
hsa_shut_down();
}
TEST(aql_helpers, get_dim_info)
{
auto agents = agent::get_agents();
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/context/correlation_id.cpp
+10
Wyświetl plik
@@ -137,6 +137,16 @@ correlation_id::sub_kern_count()
correlation_id*
correlation_tracing_service::construct(uint32_t _init_ref_count)
{
// During finalization, we cannot create correlation IDs.
// This can happen when HSA async threads call APIs after finalization starts.
// This is not an error condition - just return nullptr and let the caller handle it.
if(registration::get_fini_status() != 0)
{
ROCP_TRACE << "correlation_tracing_service::construct called during finalization"
<< " (fini_status=" << registration::get_fini_status() << "), returning nullptr";
return nullptr;
}
ROCP_FATAL_IF(_init_ref_count == 0) << "must have reference count > 0";
auto _internal_id = get_unique_internal_id();
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/abi.cpp
+6
Wyświetl plik
@@ -59,6 +59,8 @@ ROCP_SDK_ENFORCE_ABI_VERSIONING(::AmdExtTable, 74);
ROCP_SDK_ENFORCE_ABI_VERSIONING(::AmdExtTable, 75);
#elif HSA_AMD_EXT_API_TABLE_STEP_VERSION == 0x08
ROCP_SDK_ENFORCE_ABI_VERSIONING(::AmdExtTable, 77);
#elif HSA_AMD_EXT_API_TABLE_STEP_VERSION == 0x09
ROCP_SDK_ENFORCE_ABI_VERSIONING(::AmdExtTable, 79);
#else
INTERNAL_CI_ROCP_SDK_ENFORCE_ABI_VERSIONING(::AmdExtTable, 0);
#endif
@@ -299,6 +301,10 @@ ROCP_SDK_ENFORCE_ABI(::AmdExtTable, hsa_amd_portable_export_dmabuf_v2_fn, 74);
ROCP_SDK_ENFORCE_ABI(::AmdExtTable, hsa_amd_ais_file_write_fn, 75);
ROCP_SDK_ENFORCE_ABI(::AmdExtTable, hsa_amd_ais_file_read_fn, 76);
#endif
#if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x09
ROCP_SDK_ENFORCE_ABI(::AmdExtTable, hsa_amd_counted_queue_acquire_fn, 77);
ROCP_SDK_ENFORCE_ABI(::AmdExtTable, hsa_amd_counted_queue_release_fn, 78);
#endif
ROCP_SDK_ENFORCE_ABI(::ImageExtTable, hsa_ext_image_get_capability_fn, 1);
ROCP_SDK_ENFORCE_ABI(::ImageExtTable, hsa_ext_image_data_get_info_fn, 2);
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/async_copy.cpp
+10
Wyświetl plik
@@ -693,6 +693,16 @@ async_copy_impl(Args... args)
_corr_id_pop = _data->correlation_id;
}
if(!_data->correlation_id)
{
// During finalization - cleanup and execute without tracing
ROCP_HSA_TABLE_CALL(ERROR, get_core_table()->hsa_signal_destroy_fn(_data->rocp_signal));
delete _data;
return invoke(get_next_dispatch<TableIdx, OpIdx>(),
std::move(_tied_args),
std::make_index_sequence<N>{});
}
// increase the reference count to denote that this correlation id is being used in a kernel
_data->correlation_id->add_ref_count();
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/hsa.cpp
+16 -5
Wyświetl plik
@@ -336,11 +336,22 @@ hsa_api_impl<TableIdx, OpIdx>::functor(Args... args)
return;
}
auto buffer_record = common::init_public_api_struct(buffer_hsa_api_record_t{});
auto tracer_data = common::init_public_api_struct(callback_hsa_api_data_t{});
auto* corr_id = tracing::correlation_service::construct(ref_count);
auto internal_corr_id = corr_id->internal;
auto ancestor_corr_id = corr_id->ancestor;
auto buffer_record = common::init_public_api_struct(buffer_hsa_api_record_t{});
auto tracer_data = common::init_public_api_struct(callback_hsa_api_data_t{});
auto* corr_id = tracing::correlation_service::construct(ref_count);
// During finalization, correlation ID construction may return nullptr
if(!corr_id)
{
[[maybe_unused]] auto _ret = exec(info_type::get_table_func(), std::forward<Args>(args)...);
if constexpr(!std::is_void<RetT>::value)
return _ret;
else
return;
}
auto internal_corr_id = corr_id->internal;
auto ancestor_corr_id = corr_id->ancestor;
tracing::populate_external_correlation_ids(external_corr_ids,
thr_id,
external_corr_id_domain_idx,
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/hsa.def.cpp
+18
Wyświetl plik
@@ -518,6 +518,24 @@ HSA_API_INFO_DEFINITION_V(ROCPROFILER_HSA_TABLE_ID_AmdExt,
size_copied,
status)
# endif
# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x09
HSA_API_INFO_DEFINITION_V(ROCPROFILER_HSA_TABLE_ID_AmdExt,
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_acquire,
hsa_amd_counted_queue_acquire,
hsa_amd_counted_queue_acquire_fn,
agent,
type,
priority,
callback,
data,
flags,
queue)
HSA_API_INFO_DEFINITION_V(ROCPROFILER_HSA_TABLE_ID_AmdExt,
ROCPROFILER_HSA_AMD_EXT_API_ID_hsa_amd_counted_queue_release,
hsa_amd_counted_queue_release,
hsa_amd_counted_queue_release_fn,
queue)
# endif
# endif
#elif defined(ROCPROFILER_LIB_ROCPROFILER_HSA_ASYNC_COPY_CPP_IMPL) && \
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/memory_allocation.cpp
+16
Wyświetl plik
@@ -503,6 +503,14 @@ memory_allocation_impl(Args... args)
_data.correlation_id->add_ref_count();
}
if(!_data.correlation_id)
{
// During finalization - execute without tracing
return invoke(get_next_dispatch<TableIdx, OpIdx>(),
std::move(_tied_args),
std::make_index_sequence<N>{});
}
auto thr_id = _data.correlation_id->thread_idx;
tracing::populate_external_correlation_ids(
tracing_data.external_correlation_ids,
@@ -629,6 +637,14 @@ memory_free_impl(Args... args)
_data.correlation_id->add_ref_count();
}
if(!_data.correlation_id)
{
// During finalization - execute without tracing
return invoke(get_next_dispatch<TableIdx, OpIdx>(),
std::move(_tied_args),
std::make_index_sequence<N>{});
}
auto thr_id = _data.correlation_id->thread_idx;
tracing::populate_external_correlation_ids(
tracing_data.external_correlation_ids,
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/hsa/queue.cpp
+7 -22
Wyświetl plik
@@ -70,14 +70,6 @@ namespace hsa
{
namespace
{
constexpr int64_t NUM_SIGNALS = 16;
std::atomic<int64_t>&
get_balanced_signal_slots()
{
static auto*& atomic = common::static_object<std::atomic<int64_t>>::construct(NUM_SIGNALS);
return *atomic;
}
template <typename DomainT, typename... Args>
inline bool
context_filter(const context::context* ctx, DomainT domain, Args... args)
@@ -117,8 +109,6 @@ AsyncSignalHandler(hsa_signal_value_t /*signal_v*/, void* data)
return false;
}
get_balanced_signal_slots().fetch_add(1);
auto& shared_ptr_info = *static_cast<std::shared_ptr<Queue::queue_info_session_t>*>(data);
auto& queue_info_session = *shared_ptr_info;
@@ -290,6 +280,13 @@ WriteInterceptor(const void* packets,
_corr_id_pop = corr_id;
}
if(!corr_id)
{
// During finalization - just write packet through without tracing
transformed_packets.emplace_back(packets_arr[i]);
continue;
}
// increase the reference count to denote that this correlation id is being used in a kernel
corr_id->add_ref_count();
corr_id->add_kern_count();
@@ -376,13 +373,6 @@ WriteInterceptor(const void* packets,
thr_id,
ROCPROFILER_EXTERNAL_CORRELATION_REQUEST_KERNEL_DISPATCH);
// If there is a lot of contention for HSA signals, then schedule out the thread
if(get_balanced_signal_slots().fetch_sub(1) <= 0)
{
sched_yield();
std::this_thread::sleep_for(std::chrono::nanoseconds(100));
}
// Stores the instrumentation pkt (i.e. AQL packets for counter collection)
// along with an ID of the client we got the packet from (this will be returned via
// completed_cb_t)
@@ -689,11 +679,6 @@ Queue::sync() const
_core_api.hsa_signal_wait_relaxed_fn(
_active_kernels, HSA_SIGNAL_CONDITION_EQ, 0, UINT64_MAX, HSA_WAIT_STATE_ACTIVE);
}
// get_balanced_signal_slots() increments upon kernel dispatch completion and decrements in
// WriteInterceptor with a starting value of NUM_SIGNALS, so the get_balanced_signal_slots()
// should be equivalent to NUM_SIGNALS if all kernel dispatches are completed
ROCP_CI_LOG_IF(WARNING, get_balanced_signal_slots().load() != NUM_SIGNALS) << fmt::format(
"There are {} incomplete dispatches", NUM_SIGNALS - get_balanced_signal_slots().load());
}
void
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/ompt/ompt.cpp
+10 -3
Wyświetl plik
@@ -147,6 +147,7 @@ ompt_task_create_callback(ompt_data_t* encountering_task_data,
flags,
has_dependences,
codeptr_ra);
if(!corr_id) return; // During finalization
auto* state = new ompt_task_save_state{corr_id, flags};
INTERNAL(new_task_data)->ptr = state;
@@ -161,6 +162,7 @@ ompt_task_schedule_callback(ompt_data_t* prior_task_data,
{
auto* corr_id = ompt_impl<ROCPROFILER_OMPT_ID_task_schedule>::event_common(
CLIENT(prior_task_data), prior_task_status, CLIENT(next_task_data));
if(!corr_id) return; // During finalization
context::pop_latest_correlation_id(corr_id);
corr_id->sub_ref_count();
@@ -928,9 +930,13 @@ ompt_impl<OpIdx>::event_common(Args... args)
buffered_contexts,
external_corr_ids);
auto buffer_record = common::init_public_api_struct(buffer_ompt_record_t{});
auto tracer_data = common::init_public_api_struct(callback_ompt_data_t{});
auto* corr_id = tracing::correlation_service::construct(ref_count);
auto buffer_record = common::init_public_api_struct(buffer_ompt_record_t{});
auto tracer_data = common::init_public_api_struct(callback_ompt_data_t{});
auto* corr_id = tracing::correlation_service::construct(ref_count);
// During finalization, correlation ID construction may return nullptr
if(!corr_id) return nullptr;
uint64_t internal_corr_id = corr_id->internal;
uint64_t ancestor_corr_id = corr_id->ancestor;
@@ -981,6 +987,7 @@ void
ompt_impl<OpIdx>::event(Args&&... args)
{
auto corr_id = ompt_impl<OpIdx>::event_common(std::forward<Args>(args)...);
if(!corr_id) return; // During finalization
context::pop_latest_correlation_id(corr_id);
corr_id->sub_ref_count();
}
projects/rocprofiler-sdk/source/lib/rocprofiler-sdk/tests/external_correlation.cpp
+2 -4
Wyświetl plik
@@ -198,20 +198,18 @@ tool_tracing_buffered(rocprofiler_context_id_t context,
<< ", drop_count=" << drop_count << ", start=" << record->start_timestamp
<< ", stop=" << record->end_timestamp;
static int64_t last_corr_id = -1;
auto corr_id = static_cast<int64_t>(record->correlation_id.internal);
auto corr_id = static_cast<int64_t>(record->correlation_id.internal);
std::cout << info.str() << "\n" << std::flush;
EXPECT_GE(context.handle, 0) << info.str();
EXPECT_GT(record->thread_id, 0) << info.str();
EXPECT_GT(record->kind, 0) << info.str();
EXPECT_GT(corr_id, last_corr_id) << info.str();
EXPECT_GT(corr_id, 0) << info.str();
EXPECT_GT(record->start_timestamp, 0) << info.str();
EXPECT_GT(record->end_timestamp, 0) << info.str();
EXPECT_LE(record->start_timestamp, record->end_timestamp) << info.str();
cb_data->client_callback_count++;
last_corr_id = corr_id;
}
}
projects/rocprofiler-sdk/source/scripts/address-sanitizer-suppr.txt
+24
Wyświetl plik
@@ -0,0 +1,24 @@
#
# AddressSanitizer suppressions file for rocprofiler project.
#
# ASAN uses interceptor_via_lib and interceptor_via_fun for suppressing
# issues in specific libraries or functions.
#
# Suppress issues in HSA runtime library
interceptor_via_lib:libhsa-runtime64.so
# Suppress issues in HIP runtime library
interceptor_via_lib:libamdhip64.so
# Suppress issues in ROCm SMI library
interceptor_via_lib:librocm_smi64.so
# Suppress issues in AQL profile library
interceptor_via_lib:libhsa-amd-aqlprofile64.so
# Suppress issues in comgr library
interceptor_via_lib:libamd_comgr.so
# Suppress issues in perfetto library (if linked dynamically)
interceptor_via_lib:libperfetto.so
projects/rocprofiler-sdk/source/scripts/format-deps.py
+2 -4
Wyświetl plik
@@ -92,13 +92,11 @@ class FormatAll(argparse.Action):
class InstallDepsUbuntu(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
os.system(
"sudo apt-get update; \
os.system("sudo apt-get update; \
sudo apt-get install -y python3-pip software-properties-common wget curl clang-format-11; \
python3 -m pip install -U cmake-format; \
python -m pip install --upgrade pip; \
python -m pip install black"
)
python -m pip install black")
exit(0)
projects/rocprofiler-sdk/source/scripts/leak-sanitizer-suppr.txt
+15
Wyświetl plik
@@ -10,3 +10,18 @@ leak:hsa-amd-aqlprofile
leak:__new_exitfn
leak:omptarget
leak:llvm
leak:bash
# Suppress leaks from external tools and libraries
leak:liblzma
leak:liblsan
leak:seq
leak:__GI___strdup
# Suppress leaks during tool detach/shutdown - these allocations are
# intentionally not freed as the process is exiting
leak:rocprofiler::tool::metadata::get_string_entries
leak:rocprofiler::tool::write_rocpd
leak:rocprofiler::tool::generate_output
leak:tool_detach
leak:rocprofiler_register_detach
projects/rocprofiler-sdk/source/scripts/run-ci.py
+40 -1
Wyświetl plik
@@ -116,15 +116,39 @@ def generate_custom(args, cmake_args, ctest_args):
MEMCHECK_SUPPRESSION_FILE = ""
if MEMCHECK_TYPE == "AddressSanitizer":
MEMCHECK_SANITIZER_OPTIONS = "detect_leaks=0 use_sigaltstack=0"
# print_suppressions=1 shows which suppressions matched during the run
MEMCHECK_SANITIZER_OPTIONS = (
"detect_leaks=0 use_sigaltstack=0 print_suppressions=1"
)
MEMCHECK_SUPPRESSION_FILE = (
f"{SOURCE_DIR}/source/scripts/address-sanitizer-suppr.txt"
)
os.environ["ASAN_OPTIONS"] = " ".join(
[
"detect_leaks=0",
"use_sigaltstack=0",
"print_suppressions=1",
f"suppressions={SOURCE_DIR}/source/scripts/address-sanitizer-suppr.txt",
os.environ.get("ASAN_OPTIONS", ""),
]
)
elif MEMCHECK_TYPE == "LeakSanitizer":
# fast_unwind_on_malloc=1 avoids deadlock in libgcc unwinder during early init
# print_suppressions=1 shows which suppressions matched during the run
MEMCHECK_SANITIZER_OPTIONS = "fast_unwind_on_malloc=1 print_suppressions=1"
MEMCHECK_SUPPRESSION_FILE = (
f"{SOURCE_DIR}/source/scripts/leak-sanitizer-suppr.txt"
)
os.environ["LSAN_OPTIONS"] = " ".join(
[
f"suppressions={SOURCE_DIR}/source/scripts/leak-sanitizer-suppr.txt",
"fast_unwind_on_malloc=1",
"print_suppressions=1",
os.environ.get("LSAN_OPTIONS", ""),
]
)
elif MEMCHECK_TYPE == "ThreadSanitizer":
# print_suppressions=1 shows which suppressions matched during the run
external_symbolizer_path = ""
for version in range(8, 20):
_symbolizer = shutil.which(f"llvm-symbolizer-{version}")
@@ -134,6 +158,7 @@ def generate_custom(args, cmake_args, ctest_args):
[
"history_size=5",
"detect_deadlocks=0",
"print_suppressions=1",
f"suppressions={SOURCE_DIR}/source/scripts/thread-sanitizer-suppr.txt",
external_symbolizer_path,
os.environ.get("TSAN_OPTIONS", ""),
@@ -151,6 +176,20 @@ def generate_custom(args, cmake_args, ctest_args):
]
)
# Print suppression file contents for debugging
if MEMCHECK_TYPE:
print(f"\n{'=' * 60}")
print(f"Sanitizer: {MEMCHECK_TYPE}")
print(f"{'=' * 60}")
# Print environment variables for sanitizers that use them
for env_var in ["TSAN_OPTIONS", "UBSAN_OPTIONS", "ASAN_OPTIONS", "LSAN_OPTIONS"]:
if env_var in os.environ:
print(f"\n{env_var}:")
print(f" {os.environ[env_var]}")
print(f"\n{'=' * 60}\n")
codecov_exclude = [
"/usr/.*",
"/opt/.*",
projects/rocprofiler-sdk/source/scripts/setup-sanitizer-env.sh
+1 -1
Wyświetl plik
@@ -33,7 +33,7 @@ if [ -n "${EXTERNAL_SYMBOLIZER_PATH}" ]; then
fi
: ${ASAN_OPTIONS="detect_leaks=0 use_sigaltstack=0 suppressions=${SUPPR_DIR}/address-sanitizer-suppr.txt"}
: ${LSAN_OPTIONS="suppressions=${SUPPR_DIR}/leak-sanitizer-suppr.txt"}
: ${LSAN_OPTIONS="fast_unwind_on_malloc=1 suppressions=${SUPPR_DIR}/leak-sanitizer-suppr.txt"}
: ${TSAN_OPTIONS="history_size=5 detect_deadlocks=0 suppressions=${SUPPR_DIR}/thread-sanitizer-suppr.txt${EXTERNAL_SYMBOLIZER}"}
: ${UBSAN_OPTIONS="print_stacktrace=1 suppressions=${SUPPR_DIR}/undef-behavior-sanitizer-suppr.txt${EXTERNAL_SYMBOLIZER}"}
projects/rocprofiler-sdk/source/scripts/thread-sanitizer-suppr.txt
+14 -1
Wyświetl plik
@@ -29,11 +29,24 @@ race:tzset_internal
# double mutex lock (there isn't one)
mutex:external/ptl/source/PTL/TaskGroup.hh
# data race in PTL TaskGroup between worker thread finishing and
# main thread accessing shared_ptr in wait(). The shared_ptr refcount
# may be accessed concurrently after wait() returns but before worker
# thread fully completes its bookkeeping.
race:rocprofiler::internal_threading::TaskGroup::wait
race:PTL::PackagedTask
# lock order inversion that cannot happen
mutex:source/lib/common/synchronized.hpp
# signal-unsafe function called from signal handler
signal:rocprofv3_error_signal_handler
# data race within perfetto internals
# data race within perfetto internals (includes TracingMuxer and protozero)
race:perfetto::internal::
race:perfetto::protos::
race:protozero::
# False positive: C++11 guarantees thread-safe static local variable initialization.
# TSAN incorrectly reports a race on the static initialization in create_write_functor.
race:rocprofiler::hip::stream::create_write_functor
projects/rocprofiler-sdk/source/scripts/undef-behavior-sanitizer-suppr.txt
+66
Wyświetl plik
@@ -0,0 +1,66 @@
#
# UndefinedBehaviorSanitizer suppressions file for rocprofiler project.
#
# UBSAN suppressions use the format: type:pattern
# where type can be: alignment, bool, bounds, enum, float-cast-overflow,
# float-divide-by-zero, function, integer-divide-by-zero, null, object-size,
# pointer-overflow, return, returns-nonnull-attribute, shift, signed-integer-overflow,
# unreachable, unsigned-integer-overflow, vla-bound, vptr
#
# Suppress undefined behavior in HSA runtime
vptr:libhsa-runtime64.so
function:libhsa-runtime64.so
# Suppress undefined behavior in HIP runtime
vptr:libamdhip64.so
function:libamdhip64.so
# Suppress undefined behavior in ROCm SMI
vptr:librocm_smi64.so
# Suppress undefined behavior in comgr
vptr:libamd_comgr.so
# Suppress alignment issues in external libraries
alignment:libhsa-runtime64.so
alignment:libamdhip64.so
# Suppress issues in perfetto (includes TracingMuxer and protozero)
vptr:perfetto::
function:perfetto::
vptr:protozero::
function:protozero::
vptr:perfetto::internal::
function:perfetto::internal::
vptr:perfetto::protos::
function:perfetto::protos::
# Suppress issues arising from OpenMP
vptr:__kmp_resume_template
function:__kmp_resume_template
vptr:__kmp_suspend_initialize_thread
function:__kmp_suspend_initialize_thread
# Suppress issues in google logging
vptr:google::LogMessageTime::CalcGmtOffset
function:google::LogMessageTime::CalcGmtOffset
vptr:tzset_internal
function:tzset_internal
# Suppress issues in PTL TaskGroup
vptr:PTL::TaskGroup
function:PTL::TaskGroup
vptr:PTL::PackagedTask
function:PTL::PackagedTask
vptr:rocprofiler::internal_threading::TaskGroup
function:rocprofiler::internal_threading::TaskGroup
# Suppress issues in synchronized.hpp
vptr:source/lib/common/synchronized.hpp
function:source/lib/common/synchronized.hpp
# Suppress issues in AQL profile library
vptr:libhsa-amd-aqlprofile64.so
function:libhsa-amd-aqlprofile64.so
alignment:libhsa-amd-aqlprofile64.so
projects/rocprofiler-sdk/tests/async-copy-tracing/validate.py
-1
Wyświetl plik
@@ -25,7 +25,6 @@
import sys
import pytest
test_api_traces = [
"hsa_api_traces",
"marker_api_traces",
projects/rocprofiler-sdk/tests/bin/module-loading-test/main.cpp
+2 -2
Wyświetl plik
@@ -223,8 +223,8 @@ main()
std::cout << "Found " << num_gpus << " GPU(s)\n";
int num_threads =
std::thread::hardware_concurrency(); // More threads than GPUs to increase contention
// Cap at 64 threads to avoid overwhelming the system while still testing concurrency
int num_threads = std::min(std::thread::hardware_concurrency(), 64u);
int threads_per_gpu = num_threads / num_gpus;
std::cout << "Launching " << num_threads << " threads\n";
projects/rocprofiler-sdk/tests/pytest-packages/pc_sampling/stochastic/csv/gfx9/s_instructions/__init__.py
-1
Wyświetl plik
@@ -34,7 +34,6 @@ from .jump_instructions import validate_jump_instructions
from .message_instructions import validate_message_instructions
from .barrier_instructions import validate_barrier_instructions
# Using Prefix Tree to classify the instruction type
# I did this instead of the regex becuase I wanted to try if we could
# generalize this approach for other types of instructions.
projects/rocprofiler-sdk/tests/pytest-packages/pytest_utils/perfetto_reader.py
+4 -9
Wyświetl plik
@@ -31,7 +31,6 @@ import pandas as pd
from collections import OrderedDict
from perfetto.trace_processor import TraceProcessor, TraceProcessorConfig
PerfettoTraceProcessorShellPath = os.path.join(
os.path.dirname(__file__), "trace_processor_shell"
)
@@ -283,8 +282,7 @@ class PerfettoReader:
"SELECT slice_id, track_id, category, depth, stack_id, parent_stack_id, ts, dur, name FROM slice"
)
counter_df = self.query_tp(
"""SELECT
counter_df = self.query_tp("""SELECT
counter_track.id as slice_id,
counter.track_id,
counter_track.name as track_name,
@@ -299,8 +297,7 @@ class PerfettoReader:
JOIN counter ON counter.track_id = counter_track.id
WHERE counter_track.name LIKE 'AGENT%'
AND counter.value > 0
GROUP BY counter.track_id"""
)
GROUP BY counter.track_id""")
# Transform counter data to match the main dataframe schema
if not counter_df.empty:
@@ -343,8 +340,7 @@ class PerfettoReader:
[self.dataframe, counter_collection_df], ignore_index=True
)
scratch_df = self.query_tp(
"""WITH Pairs AS(
scratch_df = self.query_tp("""WITH Pairs AS(
SELECT
counter.id as slice_id,
track_id,
@@ -366,8 +362,7 @@ class PerfettoReader:
ts,
dur,
Pairs.track_name as name
FROM Pairs WHERE (rn % 2 == 1) ORDER BY slice_id"""
)
FROM Pairs WHERE (rn % 2 == 1) ORDER BY slice_id""")
# Transform scratch memory data to match the main dataframe schema
if not scratch_df.empty:
projects/rocprofiler-sdk/tests/pytest-packages/tests/rocprofv3.py
+22 -2
Wyświetl plik
@@ -428,11 +428,31 @@ def test_csv_data(
if None in (csv_start_col, json_start_col, csv_end_col, json_end_col):
continue
# Helper to get correlation_id for tiebreaking when timestamps are identical
def get_csv_corr_id(x):
return int(x.get("Correlation_Id", 0))
def get_json_corr_id(x):
corr = x.get("correlation_id", {})
if isinstance(corr, dict):
return int(corr.get("internal", 0))
return int(corr) if corr else 0
_csv_data_sorted = sorted(
_csv_data, key=lambda x: (int(x[csv_start_col]), int(x[csv_end_col]))
_csv_data,
key=lambda x: (
int(x[csv_start_col]),
int(x[csv_end_col]),
get_csv_corr_id(x),
),
)
_js_data_sorted = sorted(
_js_data, key=lambda x: (int(x[json_start_col]), int(x[json_end_col]))
_js_data,
key=lambda x: (
int(x[json_start_col]),
int(x[json_end_col]),
get_json_corr_id(x),
),
)
for a, b in zip(_csv_data_sorted, _js_data_sorted):
projects/rocprofiler-sdk/tests/rocprofv3-avail/CMakeLists.txt
+3 -1
Wyświetl plik
@@ -15,9 +15,11 @@ set(PRELOAD_ENV "${ROCPROFILER_MEMCHECK_PRELOAD_ENV_VALUE}")
# disable when GPU-0 is navi2, navi3, and navi4
list(GET rocprofiler-sdk-tests-gfx-info 0 pc-sampling-gpu-0-gfx-info)
# Disable for all sanitizers - Python tests cannot load sanitizer libs dynamically due to
# static TLS block allocation limitations
if("${pc-sampling-gpu-0-gfx-info}" MATCHES "^gfx(10|11|12)[0-9][0-9]$"
OR "${pc-sampling-gpu-0-gfx-info}" MATCHES "^gfx906$"
OR ROCPROFILER_MEMCHECK STREQUAL "AddressSanitizer")
OR ROCPROFILER_MEMCHECK)
set(IS_DISABLED ON)
endif()
projects/rocprofiler-sdk/tests/rocprofv3/attachment/attach-once/CMakeLists.txt
+1 -2
Wyświetl plik
@@ -25,8 +25,7 @@ else()
set(LOG_LEVEL "info")
endif()
string(REPLACE "LD_PRELOAD=" "ROCPROF_PRELOAD=" PRELOAD_ENV
"${ROCPROFILER_MEMCHECK_PRELOAD_ENV}")
set(PRELOAD_ENV "${ROCPROFILER_MEMCHECK_PRELOAD_ENV_VALUE}")
set(attachment-env
"LD_LIBRARY_PATH=$<TARGET_FILE_DIR:rocprofiler-sdk::rocprofiler-sdk-shared-library>:$ENV{LD_LIBRARY_PATH}"
projects/rocprofiler-sdk/tests/rocprofv3/attachment/attach-twice/CMakeLists.txt
+3 -7
Wyświetl plik
@@ -13,11 +13,8 @@ find_package(rocprofiler-sdk REQUIRED)
set(ROCPROFILER_MEMCHECK_TYPES "AddressSanitizer" "UndefinedBehaviorSanitizer"
"ThreadSanitizer")
if(ROCPROFILER_MEMCHECK AND ROCPROFILER_MEMCHECK IN_LIST ROCPROFILER_MEMCHECK_TYPES)
set(IS_DISABLED ON)
else()
set(IS_DISABLED OFF)
endif()
# Unconditionally disabled: test has known data race in tool
set(IS_DISABLED ON)
if(ROCPROFILER_MEMCHECK STREQUAL "LeakSanitizer")
set(LOG_LEVEL "warning") # info produces memory leak
@@ -25,8 +22,7 @@ else()
set(LOG_LEVEL "info")
endif()
string(REPLACE "LD_PRELOAD=" "ROCPROF_PRELOAD=" PRELOAD_ENV
"${ROCPROFILER_MEMCHECK_PRELOAD_ENV}")
set(PRELOAD_ENV "${ROCPROFILER_MEMCHECK_PRELOAD_ENV_VALUE}")
# Test that launches the app and reattaches to it twice (CSV format)
rocprofiler_add_integration_execute_test(
projects/rocprofiler-sdk/tests/rocprofv3/pc-sampling/host-trap/exec-mask-manipulation/validate.py
-1
Wyświetl plik
@@ -28,7 +28,6 @@ import pytest
import numpy as np
import pandas as pd
# =========================== Validating CSV output
projects/rocprofiler-sdk/tests/rocprofv3/pc-sampling/stochastic/exec-mask-manipulation/validate.py
-1
Wyświetl plik
@@ -27,7 +27,6 @@ import pytest
import numpy as np
import pandas as pd
# =========================== Validating fields common for both host-trap and stochastic CSV output
projects/rocprofiler-sdk/tests/thread-trace/agent.cpp
+48 -18
Wyświetl plik
@@ -27,6 +27,8 @@
#include "trace_callbacks.hpp"
#include <atomic>
#include <mutex>
#include <set>
namespace ATTTest
@@ -37,6 +39,32 @@ rocprofiler_client_id_t* client_id = nullptr;
rocprofiler_context_id_t agent_ctx = {};
rocprofiler_context_id_t tracing_ctx = {};
// Callback state allocated on heap to control destruction order
struct CallbackState
{
std::atomic<bool> isprofiling{false};
std::atomic<bool> stop_profiling{false};
std::mutex mut{};
std::set<int> captured_ids{};
};
CallbackState* callback_state = nullptr;
void
tool_fini(void* tool_data)
{
// Stop contexts to ensure no more callbacks are dispatched before static destruction
rocprofiler_stop_context(tracing_ctx);
rocprofiler_stop_context(agent_ctx);
// Call the shared finalize logic
Callbacks::finalize(tool_data);
// Clean up heap-allocated callback state after finalize
delete callback_state;
callback_state = nullptr;
}
void
dispatch_tracing_callback(rocprofiler_callback_tracing_record_t record,
rocprofiler_user_data_t* /* user_data */,
@@ -45,45 +73,44 @@ dispatch_tracing_callback(rocprofiler_callback_tracing_record_t record,
if(record.kind != ROCPROFILER_CALLBACK_TRACING_KERNEL_DISPATCH) return;
if(record.phase == ROCPROFILER_CALLBACK_PHASE_EXIT) return;
// Check if callback_state is still valid (may be null during shutdown)
if(!callback_state) return;
assert(record.payload);
auto* rdata = static_cast<rocprofiler_callback_tracing_kernel_dispatch_data_t*>(record.payload);
auto dispatch_id = rdata->dispatch_info.dispatch_id;
// Choose two dispatches to begin(6) and end(10) the trace
constexpr uint64_t begin_dispatch = 6;
constexpr uint64_t end_dispatch = 10;
static std::atomic<bool> isprofiling{false};
static std::atomic<bool> stop_profiling{false};
static std::mutex mut{};
static std::set<int> captured_ids{};
constexpr uint64_t begin_dispatch = 6;
constexpr uint64_t end_dispatch = 10;
if(record.phase == ROCPROFILER_CALLBACK_PHASE_ENTER)
{
if(dispatch_id == begin_dispatch)
{
ROCPROFILER_CALL(rocprofiler_start_context(agent_ctx), "context start");
isprofiling.store(true);
callback_state->isprofiling.store(true);
}
if(isprofiling && dispatch_id <= end_dispatch)
if(callback_state->isprofiling && dispatch_id <= end_dispatch)
{
std::unique_lock<std::mutex> lk(mut);
captured_ids.insert(dispatch_id);
std::unique_lock<std::mutex> lk(callback_state->mut);
callback_state->captured_ids.insert(dispatch_id);
}
if(dispatch_id > end_dispatch) stop_profiling.store(true);
if(dispatch_id > end_dispatch) callback_state->stop_profiling.store(true);
return;
}
assert(record.phase == ROCPROFILER_CALLBACK_PHASE_NONE);
if(!isprofiling) return;
if(!callback_state->isprofiling) return;
std::unique_lock<std::mutex> lk(mut);
captured_ids.erase(dispatch_id);
if(!captured_ids.empty() || stop_profiling == false) return;
std::unique_lock<std::mutex> lk(callback_state->mut);
callback_state->captured_ids.erase(dispatch_id);
if(!callback_state->captured_ids.empty() || callback_state->stop_profiling == false) return;
bool _exp = true;
if(!isprofiling.compare_exchange_strong(_exp, false, std::memory_order_relaxed)) return;
if(!callback_state->isprofiling.compare_exchange_strong(_exp, false, std::memory_order_relaxed))
return;
ROCPROFILER_CALL(rocprofiler_stop_context(agent_ctx), "context stop");
}
@@ -156,6 +183,9 @@ tool_init(rocprofiler_client_finalize_t /* fini_func */, void* /* tool_data */)
{
Callbacks::init();
// Allocate callback state on heap for controlled destruction order
callback_state = new CallbackState{};
ROCPROFILER_CALL(rocprofiler_create_context(&tracing_ctx), "context creation");
ROCPROFILER_CALL(rocprofiler_create_context(&agent_ctx), "context creation");
@@ -217,7 +247,7 @@ rocprofiler_configure(uint32_t /* version */,
static auto cfg =
rocprofiler_tool_configure_result_t{sizeof(rocprofiler_tool_configure_result_t),
&ATTTest::Agent::tool_init,
&Callbacks::finalize,
&ATTTest::Agent::tool_fini,
nullptr};
// return pointer to configure data
projects/rocprofiler-sdk/tests/tools/CMakeLists.txt
+4
Wyświetl plik
@@ -31,6 +31,10 @@ add_library(rocprofiler-sdk-c-tool SHARED)
target_sources(rocprofiler-sdk-c-tool PRIVATE c-tool.c)
target_link_libraries(rocprofiler-sdk-c-tool PRIVATE rocprofiler-sdk::rocprofiler-sdk
rocprofiler-sdk::tests-build-flags)
# Suppress -Wcpp warning from rccl/rccl.h which emits a #warning when compiled with C
# compiler This warning is treated as an error with -Werror but is harmless for this C
# compatibility test
target_compile_options(rocprofiler-sdk-c-tool PRIVATE -Wno-cpp)
set_target_properties(
rocprofiler-sdk-c-tool
PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/rocprofiler-sdk"
projects/rocr-runtime/runtime/hsa-runtime/core/inc/runtime.h
+4 -3
Wyświetl plik
@@ -694,6 +694,8 @@ class Runtime {
bool monitor_exceptions;
AsyncEvents events;
ConcurrentAsyncEvents new_events;
// control must be declared last so that events is initialized before the
// thread starts accessing it in AsyncEventsControl constructor
AsyncEventsControl control;
};
@@ -846,9 +848,6 @@ class Runtime {
// Deprecated HSA Region API GPU (for legacy APU support only)
Agent* region_gpu_;
lazy_ptr<AsyncEventsInfo> asyncSignals_;
lazy_ptr<AsyncEventsInfo> asyncExceptions_;
// System clock frequency.
uint64_t sys_clock_freq_;
@@ -908,6 +907,8 @@ class Runtime {
std::map<uint64_t, int> ipc_sock_server_conns_;
std::mutex ipc_sock_server_lock_;
lazy_ptr<AsyncEventsInfo> asyncSignals_;
lazy_ptr<AsyncEventsInfo> asyncExceptions_;
private:
void CheckVirtualMemApiSupport();
int GetAmdgpuDeviceArgs(Agent *agent, ShareableHandle handle, int *drm_fd,
projects/rocr-runtime/runtime/hsa-runtime/core/runtime/amd_blit_kernel.cpp
+11 -16
Wyświetl plik
@@ -43,6 +43,7 @@
#include "core/inc/amd_blit_kernel.h"
#include <algorithm>
#include <cstring>
#include <sstream>
#include <string>
@@ -53,8 +54,7 @@
namespace rocr {
namespace AMD {
static std::string& kBlitKernelSource() {
static std::string kBlitKernelSource_(R"(
static constexpr const char kBlitKernelSource_[] = R"(
// Compatibility function for GFXIP 7.
function s_load_dword_offset(byte_offset)
@@ -491,25 +491,20 @@ static std::string& kBlitKernelSource() {
L_FILL_PHASE_2_DONE:
s_endpgm
end
)");
return kBlitKernelSource_;
}
)";
// Search kernel source for variable definition and return value.
int GetKernelSourceParam(const char* paramName) {
std::stringstream paramDef;
paramDef << "var " << paramName << " = ";
std::string paramDef = std::string("var ") + paramName + " = ";
std::string::size_type paramDefLoc =
kBlitKernelSource().find(paramDef.str());
assert(paramDefLoc != std::string::npos);
std::string::size_type paramValLoc = paramDefLoc + paramDef.str().size();
std::string::size_type paramEndLoc =
kBlitKernelSource().find('\n', paramDefLoc);
assert(paramEndLoc != std::string::npos);
const char* paramDefPtr = strstr(kBlitKernelSource_, paramDef.c_str());
assert(paramDefPtr != nullptr);
std::string paramVal(&kBlitKernelSource()[paramValLoc],
&kBlitKernelSource()[paramEndLoc]);
const char* paramValPtr = paramDefPtr + paramDef.size();
const char* paramEndPtr = strchr(paramValPtr, '\n');
assert(paramEndPtr != nullptr);
std::string paramVal(paramValPtr, paramEndPtr);
return std::stoi(paramVal);
}
projects/rocr-runtime/runtime/hsa-runtime/core/runtime/runtime.cpp
+11 -6
Wyświetl plik
@@ -1810,6 +1810,10 @@ void Runtime::AsyncEventsLoop(void* _eventsInfo) {
};
while (!async_events_control_.exit) {
// Update hsa_signals pointer at start of each iteration since PushBack
// at the end of the previous iteration may have reallocated the vector.
hsa_signals = reinterpret_cast<hsa_signal_handle*>(&async_events_.signal_[0]);
// Wait for a signal
std::vector<hsa_signal_value_t> value(1);
value[0] = 0;
@@ -1828,8 +1832,6 @@ void Runtime::AsyncEventsLoop(void* _eventsInfo) {
// Skip wake-up signal logic
index = 1;
wait_any = false;
// The new events can reallocate the signals, hence update the pointer
hsa_signals = reinterpret_cast<hsa_signal_handle*>(&async_events_.signal_[0]);
}
}
@@ -2321,7 +2323,8 @@ void Runtime::PrintMemoryMapNear(void* ptr) {
Runtime::AsyncEventsInfo::AsyncEventsInfo(bool exceptions_)
: monitor_exceptions(exceptions_), events(), new_events(), control(this) {
// Add wake signal to events BEFORE starting thread so the thread has
// a valid signal to wait on when it begins execution
events.PushBack(control.wake, HSA_SIGNAL_CONDITION_NE, 0, NULL, NULL);
control.Start();
}
@@ -2480,13 +2483,15 @@ void Runtime::Unload() {
hw_exception_event_.reset();
SharedSignalPool.clear();
EventPool.clear();
mapped_handle_map_.clear();
memory_handle_map_.clear();
// Clear signal and event pools before destroying agents, since the pools
// contain allocations from memory regions owned by agents.
SharedSignalPool.clear();
EventPool.clear();
DestroyAgents();
CloseTools();