[SDK] KFD new events API (#321)
* Remove page-migration
* Add KFD events API
* Address review comments
* Move assert checks
* Update enum-string utils
* Update codeowners
* Update KFD header
* Add perfetto category
[ROCm/rocprofiler-sdk commit: 8a461afe20]
This commit is contained in:
Kuricheti, Mythreya
committed by
GitHub
GitHub
parent
58532974bc
commit
bde07e7baa
@@ -71,7 +71,6 @@ add_subdirectory(async-copy-tracing)
|
||||
add_subdirectory(hsa-memory-allocation)
|
||||
add_subdirectory(scratch-memory-tracing)
|
||||
add_subdirectory(c-tool)
|
||||
add_subdirectory(page-migration)
|
||||
add_subdirectory(thread-trace)
|
||||
add_subdirectory(pc_sampling)
|
||||
add_subdirectory(hip-graph-tracing)
|
||||
|
||||
@@ -27,7 +27,6 @@ add_subdirectory(multistream)
|
||||
add_subdirectory(vector-operations)
|
||||
add_subdirectory(hip-in-libraries)
|
||||
add_subdirectory(scratch-memory)
|
||||
add_subdirectory(page-migration)
|
||||
add_subdirectory(hsa-queue-dependency)
|
||||
add_subdirectory(hip-graph)
|
||||
add_subdirectory(hsa-memory-allocation)
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
#
|
||||
#
|
||||
#
|
||||
cmake_minimum_required(VERSION 3.21.0 FATAL_ERROR)
|
||||
|
||||
if(NOT CMAKE_HIP_COMPILER)
|
||||
find_program(
|
||||
amdclangpp_EXECUTABLE
|
||||
NAMES amdclang++
|
||||
HINTS ${ROCM_PATH} ENV ROCM_PATH /opt/rocm
|
||||
PATHS ${ROCM_PATH} ENV ROCM_PATH /opt/rocm
|
||||
PATH_SUFFIXES bin llvm/bin NO_CACHE)
|
||||
mark_as_advanced(amdclangpp_EXECUTABLE)
|
||||
|
||||
if(amdclangpp_EXECUTABLE)
|
||||
set(CMAKE_HIP_COMPILER "${amdclangpp_EXECUTABLE}")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
project(rocprofiler-sdk-tests-bin-page-migration LANGUAGES CXX HIP)
|
||||
|
||||
foreach(_TYPE DEBUG MINSIZEREL RELEASE RELWITHDEBINFO)
|
||||
if("${CMAKE_HIP_FLAGS_${_TYPE}}" STREQUAL "")
|
||||
set(CMAKE_HIP_FLAGS_${_TYPE} "${CMAKE_CXX_FLAGS_${_TYPE}}")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_HIP_STANDARD 17)
|
||||
set(CMAKE_HIP_EXTENSIONS OFF)
|
||||
set(CMAKE_HIP_STANDARD_REQUIRED ON)
|
||||
|
||||
set_source_files_properties(page-migration.cpp PROPERTIES LANGUAGE HIP)
|
||||
add_executable(page-migration)
|
||||
target_sources(page-migration PRIVATE page-migration.cpp)
|
||||
target_compile_options(page-migration PRIVATE -W -Wall -Wextra -Wpedantic -Wshadow
|
||||
-Werror)
|
||||
|
||||
find_package(Threads REQUIRED)
|
||||
target_link_libraries(page-migration PRIVATE Threads::Threads)
|
||||
@@ -1,300 +0,0 @@
|
||||
// MIT License
|
||||
//
|
||||
// Copyright (c) 2023-2025 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 <hip/hip_runtime.h>
|
||||
|
||||
#include <cerrno>
|
||||
#include <cstddef>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <mutex>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define HIP_API_CALL(CALL) \
|
||||
{ \
|
||||
hipError_t error_ = (CALL); \
|
||||
if(error_ != hipSuccess) \
|
||||
{ \
|
||||
auto _hip_api_print_lk = auto_lock_t{print_lock}; \
|
||||
fprintf(stderr, \
|
||||
"%s:%d :: HIP error : %s\n", \
|
||||
__FILE__, \
|
||||
__LINE__, \
|
||||
hipGetErrorString(error_)); \
|
||||
throw std::runtime_error("hip_api_call"); \
|
||||
} \
|
||||
}
|
||||
|
||||
using auto_lock_t = std::unique_lock<std::mutex>;
|
||||
auto print_lock = std::mutex{};
|
||||
|
||||
__global__ void
|
||||
kernel(size_t* __restrict__ data, int size)
|
||||
{
|
||||
int x = hipBlockDim_x * hipBlockIdx_x + hipThreadIdx_x;
|
||||
int stride = hipBlockDim_x * hipGridDim_x;
|
||||
|
||||
for(int i = x; i < size; i += stride)
|
||||
{
|
||||
data[i] *= 2;
|
||||
}
|
||||
}
|
||||
|
||||
struct mmap_allocator
|
||||
{
|
||||
explicit mmap_allocator(size_t num_pages)
|
||||
{
|
||||
m_size = num_pages * sysconf(_SC_PAGE_SIZE);
|
||||
void* ret = mmap(nullptr, // addr: null. Kernel gives us page-aligned memory
|
||||
m_size, // length: num bytes to allocate
|
||||
PROT_WRITE | PROT_READ, // mem_prot: Allow read/write
|
||||
MAP_ANONYMOUS | MAP_PRIVATE, // flags: No file handle
|
||||
-1, // no fd, use memory "MAP_ANONYMOUS"
|
||||
0); // offset into fd
|
||||
if(ret == ((void*) -1)) // NOLINT(performance-no-int-to-ptr)
|
||||
{
|
||||
auto ecode = errno;
|
||||
fprintf(stderr, "mmap error %d: %s", ecode, strerror(ecode));
|
||||
throw std::runtime_error("mmap failed");
|
||||
}
|
||||
else
|
||||
{
|
||||
m_addr = ret;
|
||||
::memset(m_addr, 0, m_size);
|
||||
}
|
||||
}
|
||||
|
||||
~mmap_allocator()
|
||||
{
|
||||
auto ret = munmap(m_addr, m_size);
|
||||
if(ret != 0) perror("munmap failed");
|
||||
}
|
||||
|
||||
mmap_allocator(const mmap_allocator&) = delete;
|
||||
mmap_allocator(mmap_allocator&&) noexcept = default;
|
||||
mmap_allocator& operator=(const mmap_allocator&) = delete;
|
||||
mmap_allocator& operator=(mmap_allocator&&) noexcept = default;
|
||||
|
||||
template <typename Up>
|
||||
Up* get() const
|
||||
{
|
||||
static_assert(!std::is_pointer<Up>::value, "must not be pointer type");
|
||||
return static_cast<Up*>(m_addr);
|
||||
}
|
||||
|
||||
private:
|
||||
size_t m_size = 0;
|
||||
void* m_addr = nullptr;
|
||||
};
|
||||
|
||||
int
|
||||
run_test(int dev_idx, int num_iter)
|
||||
{
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
constexpr size_t NUM_PAGES = 512;
|
||||
const size_t PAGE_SIZE_BYTES = ::sysconf(_SC_PAGE_SIZE);
|
||||
|
||||
const size_t elem_count = (NUM_PAGES * PAGE_SIZE_BYTES) / sizeof(size_t);
|
||||
|
||||
auto alloc = mmap_allocator(NUM_PAGES);
|
||||
void* data_v = alloc.get<void>();
|
||||
auto* data = alloc.get<size_t>();
|
||||
|
||||
for(size_t i = 0; i < elem_count; ++i)
|
||||
if(data[i] != 0) throw std::runtime_error{"bad init"};
|
||||
|
||||
printf("Allocated size: %lu bytes (%lu KB), (%lu MB), %zu elements @ %p\n",
|
||||
sizeof(size_t) * elem_count,
|
||||
sizeof(size_t) * elem_count / 1024,
|
||||
sizeof(size_t) * elem_count / 1024 / 1024,
|
||||
elem_count,
|
||||
data_v);
|
||||
|
||||
HIP_API_CALL(hipSetDevice(dev_idx));
|
||||
HIP_API_CALL(hipHostRegister(data, elem_count * sizeof(size_t), hipHostRegisterDefault));
|
||||
|
||||
constexpr size_t MAPS_BUFFER_SIZE = 1024 * 1024;
|
||||
|
||||
char maps[MAPS_BUFFER_SIZE];
|
||||
std::memset(maps, '\0', MAPS_BUFFER_SIZE);
|
||||
auto fd = open("/proc/self/maps", O_RDONLY | O_CLOEXEC);
|
||||
|
||||
if(fd == -1)
|
||||
{
|
||||
auto ecode = errno;
|
||||
fprintf(stderr, "mmap error %d: %s", ecode, strerror(ecode));
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
auto bytes = read(fd, maps, MAPS_BUFFER_SIZE - 1);
|
||||
if(bytes == -1)
|
||||
{
|
||||
auto ecode = errno;
|
||||
fprintf(stderr, "mmap error %d: %s", ecode, strerror(ecode));
|
||||
exit(-1);
|
||||
}
|
||||
close(fd);
|
||||
|
||||
std::string_view maps_data{maps, static_cast<size_t>(bytes)};
|
||||
std::cout << "------------\n";
|
||||
std::cout << maps_data;
|
||||
std::cout << "------------\n";
|
||||
std::istringstream maps_stream{maps_data.data()};
|
||||
std::string line(1024, '\0');
|
||||
|
||||
while(std::getline(maps_stream, line))
|
||||
{
|
||||
char __[1024];
|
||||
int _{};
|
||||
|
||||
void* start{};
|
||||
void* end{};
|
||||
|
||||
auto ret =
|
||||
std::sscanf(line.data(), "%p-%p %s %d %d:%d %d\n", &start, &end, __, &_, &_, &_, &_);
|
||||
if(ret > 0 && (start == data_v))
|
||||
{
|
||||
size_t ptr_diff = ((size_t) end - (size_t) start);
|
||||
printf("Found match: %zu %zu KB, %zu 4K > %s\n",
|
||||
ptr_diff,
|
||||
ptr_diff / 1024,
|
||||
ptr_diff / 4096,
|
||||
line.data());
|
||||
}
|
||||
}
|
||||
|
||||
hipStream_t stream{};
|
||||
HIP_API_CALL(hipStreamCreate(&stream));
|
||||
|
||||
for(int iter = 0; iter < num_iter; ++iter)
|
||||
{
|
||||
for(size_t i = 0; i < elem_count; ++i)
|
||||
{
|
||||
data[i] = i;
|
||||
}
|
||||
|
||||
// std::cout << "launching..." << std::endl;
|
||||
hipLaunchKernelGGL(kernel, 1024, 1024, 0, stream, data, elem_count);
|
||||
|
||||
HIP_API_CALL(hipStreamSynchronize(stream));
|
||||
|
||||
for(size_t i = 0; i < elem_count; ++i)
|
||||
{
|
||||
const auto data_i = data[i];
|
||||
if(data_i != (i * 2))
|
||||
{
|
||||
auto msg = std::stringstream{};
|
||||
msg << "GPU computed value at " << i << " in iteration " << iter
|
||||
<< " is incorrect. Expected " << (i * 2) << ", found " << data_i;
|
||||
throw std::runtime_error{msg.str()};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
HIP_API_CALL(hipStreamSynchronize(stream));
|
||||
HIP_API_CALL(hipStreamDestroy(stream));
|
||||
HIP_API_CALL(hipHostUnregister(data));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, const char** argv)
|
||||
{
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
const auto usage_msg = [](const char** _argv) {
|
||||
fprintf(stderr, "usage: %s <NUMBER OF THREADS> <ITERATIONS PER THREAD>\n", _argv[0]);
|
||||
};
|
||||
|
||||
if(argc != 3)
|
||||
{
|
||||
usage_msg(argv);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
for(int i = 1; i < argc; ++i)
|
||||
{
|
||||
auto _arg = std::string{argv[i]};
|
||||
if(_arg == "?" || _arg == "-h" || _arg == "--help")
|
||||
{
|
||||
usage_msg(argv);
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
}
|
||||
|
||||
const auto num_threads = std::atoi(argv[1]);
|
||||
if(num_threads < 1)
|
||||
{
|
||||
fprintf(stderr, "Error: Invalid value %d for num_threads (min 1)\n", num_threads);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
const auto num_iter = std::atoi(argv[2]);
|
||||
if(num_iter < 1)
|
||||
{
|
||||
fprintf(stderr, "Error: Invalid value %d for num_iter (min 1)\n", num_iter);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
int ndevice = 0;
|
||||
HIP_API_CALL(hipGetDeviceCount(&ndevice));
|
||||
|
||||
run_test(0, num_iter);
|
||||
|
||||
std::vector<std::thread> threads;
|
||||
threads.reserve(num_threads);
|
||||
|
||||
std::cerr << "Running " << num_iter << " iterations/thread on " << num_threads << " threads\n";
|
||||
for(auto i = 0; i < num_threads; ++i)
|
||||
{
|
||||
auto _dev_idx = i % ndevice;
|
||||
threads.emplace_back([_dev_idx, _num_iter = num_iter]() { run_test(_dev_idx, _num_iter); });
|
||||
}
|
||||
|
||||
std::cerr << "Waiting for threads\n";
|
||||
for(auto& t : threads)
|
||||
{
|
||||
t.join();
|
||||
}
|
||||
|
||||
for(int i = 0; i < ndevice; ++i)
|
||||
{
|
||||
HIP_API_CALL(hipSetDevice(i));
|
||||
HIP_API_CALL(hipDeviceSynchronize());
|
||||
HIP_API_CALL(hipDeviceReset());
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
#
|
||||
#
|
||||
#
|
||||
cmake_minimum_required(VERSION 3.21.0 FATAL_ERROR)
|
||||
|
||||
project(
|
||||
rocprofiler-sdk-tests-page-migration
|
||||
LANGUAGES CXX
|
||||
VERSION 0.0.0)
|
||||
|
||||
find_package(rocprofiler-sdk REQUIRED)
|
||||
|
||||
if(ROCPROFILER_MEMCHECK_PRELOAD_ENV)
|
||||
set(PRELOAD_ENV
|
||||
"${ROCPROFILER_MEMCHECK_PRELOAD_ENV}:$<TARGET_FILE:rocprofiler-sdk-json-tool>")
|
||||
else()
|
||||
set(PRELOAD_ENV "LD_PRELOAD=$<TARGET_FILE:rocprofiler-sdk-json-tool>")
|
||||
endif()
|
||||
|
||||
list(GET rocprofiler-sdk-tests-gfx-info 0 page-migration-gpu-0-gfx-info)
|
||||
|
||||
# disabled on all architectures
|
||||
if("${page-migration-gpu-0-gfx-info}" MATCHES "^gfx([0-9a-fA-F]+)$")
|
||||
set(IS_DISABLED ON)
|
||||
endif()
|
||||
|
||||
add_test(NAME test-page-migration-execute COMMAND $<TARGET_FILE:page-migration> 4 1024)
|
||||
|
||||
set(page-migration-env
|
||||
"${PRELOAD_ENV}"
|
||||
"ROCPROFILER_DISABLE_PERFETTO_ANNOTATIONS=1"
|
||||
"ROCPROFILER_TOOL_OUTPUT_FILE=page-migration-test.json"
|
||||
"ROCPROFILER_TOOL_CONTEXTS_EXCLUDE=HSA_API_BUFFERED,HSA_API_CALLBACK"
|
||||
"LD_LIBRARY_PATH=$<TARGET_FILE_DIR:rocprofiler-sdk::rocprofiler-sdk-shared-library>:$ENV{LD_LIBRARY_PATH}"
|
||||
)
|
||||
|
||||
set_tests_properties(
|
||||
test-page-migration-execute
|
||||
PROPERTIES TIMEOUT
|
||||
60
|
||||
LABELS
|
||||
"integration-tests"
|
||||
ENVIRONMENT
|
||||
"${page-migration-env}"
|
||||
FAIL_REGULAR_EXPRESSION
|
||||
"${ROCPROFILER_DEFAULT_FAIL_REGEX}"
|
||||
SKIP_REGULAR_EXPRESSION
|
||||
"KFD does not support SVM event reporting"
|
||||
WORKING_DIRECTORY
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
DISABLED
|
||||
"${IS_DISABLED}")
|
||||
|
||||
# copy to binary directory
|
||||
rocprofiler_configure_pytest_files(COPY validate.py conftest.py CONFIG pytest.ini)
|
||||
|
||||
add_test(NAME test-page-migration-validate
|
||||
COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/validate.py --input
|
||||
${CMAKE_CURRENT_BINARY_DIR}/page-migration-test.json)
|
||||
|
||||
set_tests_properties(
|
||||
test-page-migration-validate
|
||||
PROPERTIES TIMEOUT
|
||||
45
|
||||
LABELS
|
||||
"integration-tests"
|
||||
DEPENDS
|
||||
test-page-migration-execute
|
||||
FAIL_REGULAR_EXPRESSION
|
||||
"${ROCPROFILER_DEFAULT_FAIL_REGEX}"
|
||||
SKIP_REGULAR_EXPRESSION
|
||||
"KFD does not support SVM event reporting"
|
||||
WORKING_DIRECTORY
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
DISABLED
|
||||
"${IS_DISABLED}")
|
||||
@@ -1,50 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# MIT License
|
||||
#
|
||||
# Copyright (c) 2024-2025 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.
|
||||
|
||||
import json
|
||||
import pytest
|
||||
from rocprofiler_sdk.pytest_utils.dotdict import dotdict
|
||||
|
||||
|
||||
def pytest_addoption(parser):
|
||||
parser.addoption(
|
||||
"--input",
|
||||
action="store",
|
||||
default="page-migration-test.json",
|
||||
help="Input JSON",
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def input_data(request):
|
||||
filename = request.config.getoption("--input")
|
||||
data = None
|
||||
with open(filename, "r") as inp:
|
||||
data = json.load(inp)
|
||||
|
||||
if data["rocprofiler-sdk-json-tool"]["metadata"]["validate_page_migration"] is False:
|
||||
return pytest.skip(
|
||||
"Skipping test because KFD does not support SVM event reporting"
|
||||
)
|
||||
return dotdict(data)
|
||||
@@ -1,5 +0,0 @@
|
||||
|
||||
[pytest]
|
||||
addopts = --durations=20 -rA -s -vv
|
||||
testpaths = validate.py
|
||||
pythonpath = @ROCPROFILER_SDK_TESTS_BINARY_DIR@/pytest-packages
|
||||
@@ -1,377 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# MIT License
|
||||
#
|
||||
# Copyright (c) 2024-2025 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.
|
||||
|
||||
from collections import defaultdict
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
|
||||
test_api_traces = [
|
||||
"hsa_api_traces",
|
||||
"marker_api_traces",
|
||||
"hip_api_traces",
|
||||
"rccl_api_traces",
|
||||
"scratch_memory_traces",
|
||||
]
|
||||
|
||||
|
||||
# helper function
|
||||
def node_exists(name, data, min_len=1):
|
||||
assert name in data
|
||||
assert data[name] is not None
|
||||
if isinstance(data[name], (list, tuple, dict, set)):
|
||||
assert len(data[name]) >= min_len
|
||||
|
||||
|
||||
def to_dict(key_values):
|
||||
a = defaultdict()
|
||||
for kv in key_values:
|
||||
a[kv["key"]] = kv["value"]
|
||||
return a
|
||||
|
||||
|
||||
def get_operation(record, kind_name, op_name=None):
|
||||
for idx, itr in enumerate(record["names"]):
|
||||
if kind_name == itr["kind"]:
|
||||
if op_name is None:
|
||||
return idx, itr["operations"]
|
||||
else:
|
||||
for oidx, oname in enumerate(itr["operations"]):
|
||||
if op_name == oname:
|
||||
return oidx
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def dict_from_value_key(d):
|
||||
ret_d = defaultdict()
|
||||
|
||||
for k, v in d.items():
|
||||
assert v not in ret_d
|
||||
ret_d[v] = k
|
||||
return ret_d
|
||||
|
||||
|
||||
def sort_by_timestamp(lines):
|
||||
timestamp_line_map = {}
|
||||
|
||||
for log_line in lines:
|
||||
timestamp = log_line.split(" ")[1]
|
||||
timestamp_line_map[timestamp] = log_line
|
||||
|
||||
timestamps_sorted = sorted([l.split(" ")[1] for l in lines])
|
||||
return timestamps_sorted, timestamp_line_map
|
||||
|
||||
|
||||
# ------------------------------ Tests ------------------------------ #
|
||||
|
||||
|
||||
def test_data_structure(input_data):
|
||||
"""verify minimum amount of expected data is present"""
|
||||
data = input_data
|
||||
|
||||
node_exists("rocprofiler-sdk-json-tool", data)
|
||||
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
|
||||
node_exists("metadata", sdk_data)
|
||||
node_exists("pid", sdk_data["metadata"])
|
||||
node_exists("main_tid", sdk_data["metadata"])
|
||||
node_exists("init_time", sdk_data["metadata"])
|
||||
node_exists("fini_time", sdk_data["metadata"])
|
||||
node_exists("validate_page_migration", sdk_data["metadata"])
|
||||
|
||||
assert sdk_data["metadata"]["validate_page_migration"] is True
|
||||
|
||||
node_exists("agents", sdk_data)
|
||||
node_exists("call_stack", sdk_data)
|
||||
node_exists("callback_records", sdk_data)
|
||||
node_exists("buffer_records", sdk_data)
|
||||
|
||||
node_exists("names", sdk_data["callback_records"])
|
||||
node_exists("code_objects", sdk_data["callback_records"])
|
||||
node_exists("kernel_symbols", sdk_data["callback_records"])
|
||||
node_exists("host_functions", sdk_data["callback_records"])
|
||||
node_exists("hsa_api_traces", sdk_data["callback_records"], 0)
|
||||
node_exists("hip_api_traces", sdk_data["callback_records"])
|
||||
node_exists("marker_api_traces", sdk_data["callback_records"], 0)
|
||||
|
||||
node_exists("names", sdk_data["buffer_records"])
|
||||
node_exists("kernel_dispatch", sdk_data["buffer_records"])
|
||||
node_exists("memory_copies", sdk_data["buffer_records"], 0)
|
||||
node_exists("hsa_api_traces", sdk_data["buffer_records"], 0)
|
||||
node_exists("hip_api_traces", sdk_data["buffer_records"])
|
||||
node_exists("marker_api_traces", sdk_data["buffer_records"], 0)
|
||||
node_exists("retired_correlation_ids", sdk_data["buffer_records"])
|
||||
node_exists("page_migration", sdk_data["buffer_records"])
|
||||
|
||||
|
||||
def test_timestamps(input_data):
|
||||
data = input_data
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
|
||||
cb_start = {}
|
||||
cb_end = {}
|
||||
for titr in test_api_traces:
|
||||
for itr in sdk_data["callback_records"][titr]:
|
||||
cid = itr["correlation_id"]["internal"]
|
||||
phase = itr["phase"]
|
||||
if phase == 1:
|
||||
cb_start[cid] = itr["timestamp"]
|
||||
elif phase == 2:
|
||||
cb_end[cid] = itr["timestamp"]
|
||||
assert cb_start[cid] <= itr["timestamp"]
|
||||
else:
|
||||
assert phase == 1 or phase == 2
|
||||
|
||||
for itr in sdk_data["buffer_records"][titr]:
|
||||
assert itr["start_timestamp"] <= itr["end_timestamp"]
|
||||
|
||||
for titr in ["kernel_dispatch", "memory_copies"]:
|
||||
for itr in sdk_data["buffer_records"][titr]:
|
||||
assert itr["start_timestamp"] < itr["end_timestamp"]
|
||||
assert itr["correlation_id"]["internal"] > 0
|
||||
assert itr["correlation_id"]["external"] > 0
|
||||
assert sdk_data["metadata"]["init_time"] < itr["start_timestamp"]
|
||||
assert sdk_data["metadata"]["init_time"] < itr["end_timestamp"]
|
||||
assert sdk_data["metadata"]["fini_time"] > itr["start_timestamp"]
|
||||
assert sdk_data["metadata"]["fini_time"] > itr["end_timestamp"]
|
||||
|
||||
# api_start = cb_start[itr["correlation_id"]["internal"]]
|
||||
# api_end = cb_end[itr["correlation_id"]["internal"]]
|
||||
# assert api_start < itr["start_timestamp"]
|
||||
# assert api_end <= itr["end_timestamp"]
|
||||
|
||||
|
||||
def test_internal_correlation_ids(input_data):
|
||||
data = input_data
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
|
||||
api_corr_ids = []
|
||||
for titr in test_api_traces:
|
||||
for itr in sdk_data["callback_records"][titr]:
|
||||
api_corr_ids.append(itr["correlation_id"]["internal"])
|
||||
|
||||
for itr in sdk_data["buffer_records"][titr]:
|
||||
api_corr_ids.append(itr["correlation_id"]["internal"])
|
||||
|
||||
api_corr_ids_sorted = sorted(api_corr_ids)
|
||||
api_corr_ids_unique = list(set(api_corr_ids))
|
||||
|
||||
for itr in sdk_data["buffer_records"]["kernel_dispatch"]:
|
||||
assert itr["correlation_id"]["internal"] in api_corr_ids_unique
|
||||
|
||||
for itr in sdk_data["buffer_records"]["memory_copies"]:
|
||||
assert itr["correlation_id"]["internal"] in api_corr_ids_unique
|
||||
|
||||
len_corr_id_unq = len(api_corr_ids_unique)
|
||||
assert len(api_corr_ids) != len_corr_id_unq
|
||||
assert max(api_corr_ids_sorted) == len_corr_id_unq
|
||||
|
||||
|
||||
def test_external_correlation_ids(input_data):
|
||||
data = input_data
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
|
||||
extern_corr_ids = []
|
||||
for titr in test_api_traces:
|
||||
for itr in sdk_data["callback_records"][titr]:
|
||||
assert itr["correlation_id"]["external"] > 0
|
||||
assert itr["thread_id"] == itr["correlation_id"]["external"]
|
||||
extern_corr_ids.append(itr["correlation_id"]["external"])
|
||||
|
||||
extern_corr_ids = list(set(sorted(extern_corr_ids)))
|
||||
for titr in test_api_traces:
|
||||
for itr in sdk_data["buffer_records"][titr]:
|
||||
assert itr["correlation_id"]["external"] > 0
|
||||
assert itr["thread_id"] == itr["correlation_id"]["external"]
|
||||
assert itr["thread_id"] in extern_corr_ids
|
||||
assert itr["correlation_id"]["external"] in extern_corr_ids
|
||||
|
||||
for itr in sdk_data["buffer_records"]["kernel_dispatch"]:
|
||||
assert itr["correlation_id"]["external"] > 0
|
||||
assert itr["correlation_id"]["external"] in extern_corr_ids
|
||||
|
||||
for itr in sdk_data["buffer_records"]["memory_copies"]:
|
||||
assert itr["correlation_id"]["external"] > 0
|
||||
assert itr["correlation_id"]["external"] in extern_corr_ids
|
||||
|
||||
|
||||
def test_kernel_ids(input_data):
|
||||
data = input_data
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
|
||||
symbol_info = {}
|
||||
for itr in sdk_data["callback_records"]["kernel_symbols"]:
|
||||
phase = itr["phase"]
|
||||
payload = itr["payload"]
|
||||
kern_id = payload["kernel_id"]
|
||||
|
||||
assert phase == 1 or phase == 2
|
||||
assert kern_id > 0
|
||||
if phase == 1:
|
||||
assert len(payload["kernel_name"]) > 0
|
||||
symbol_info[kern_id] = payload
|
||||
elif phase == 2:
|
||||
assert payload["kernel_id"] in symbol_info.keys()
|
||||
assert payload["kernel_name"] == symbol_info[kern_id]["kernel_name"]
|
||||
|
||||
for itr in sdk_data["buffer_records"]["kernel_dispatch"]:
|
||||
assert itr["dispatch_info"]["kernel_id"] in symbol_info.keys()
|
||||
|
||||
for itr in sdk_data["callback_records"]["kernel_dispatch"]:
|
||||
assert itr["payload"]["dispatch_info"]["kernel_id"] in symbol_info.keys()
|
||||
|
||||
|
||||
def get_allocated_pages(callback_records):
|
||||
# Get how many pages we allocated
|
||||
op_idx = get_operation(callback_records, "HIP_RUNTIME_API", "hipHostRegister")
|
||||
rt_idx, rt_data = get_operation(callback_records, "HIP_RUNTIME_API")
|
||||
|
||||
assert op_idx is not None, f"{rt_idx}:\n{rt_data}"
|
||||
|
||||
host_register_record = []
|
||||
for itr in callback_records["hip_api_traces"]:
|
||||
if itr["kind"] == rt_idx and itr["operation"] == op_idx and itr["phase"] == 2:
|
||||
assert "sizeBytes" in itr["args"].keys(), f"{itr}"
|
||||
assert "hostPtr" in itr["args"].keys(), f"{itr}"
|
||||
host_register_record.append(itr)
|
||||
|
||||
num_host_register_calls = len(host_register_record)
|
||||
assert num_host_register_calls == 5, "Expected 5 hipHostRegister calls in test"
|
||||
|
||||
ret = []
|
||||
for i in range(num_host_register_calls):
|
||||
alloc_size = int(host_register_record[0]["args"]["sizeBytes"], 10)
|
||||
start_addr = int(host_register_record[0]["args"]["hostPtr"], 16)
|
||||
end_addr = start_addr + alloc_size
|
||||
ret.append((start_addr, end_addr))
|
||||
return ret
|
||||
|
||||
|
||||
def validate_node(id, nodes):
|
||||
assert id.handle in nodes
|
||||
|
||||
|
||||
def test_page_migration_data(input_data):
|
||||
data = input_data
|
||||
sdk_data = data["rocprofiler-sdk-json-tool"]
|
||||
buffer_records = sdk_data.buffer_records
|
||||
callback_records = sdk_data.callback_records
|
||||
page_migtation_buffers = buffer_records.page_migration
|
||||
|
||||
_, bf_op_names = get_operation(buffer_records, "PAGE_MIGRATION")
|
||||
assert bf_op_names[0] == "PAGE_MIGRATION_NONE"
|
||||
|
||||
for op_name in bf_op_names:
|
||||
assert "PAGE_MIGRATION" in op_name
|
||||
|
||||
assert len(bf_op_names) == 9
|
||||
|
||||
nodes = set(x.id.handle for x in sdk_data.agents)
|
||||
allocations = get_allocated_pages(callback_records)
|
||||
|
||||
for start_addr, end_addr in allocations:
|
||||
|
||||
assert (
|
||||
start_addr < end_addr
|
||||
), "Expected start address less than end address for mmap range"
|
||||
alloc_size = end_addr - start_addr
|
||||
assert int(alloc_size) == 512 * 4096 # We allocated 512 pages in the test
|
||||
|
||||
# PID must be same
|
||||
assert len(set(r.pid for r in page_migtation_buffers)) == 1
|
||||
|
||||
for r in page_migtation_buffers:
|
||||
op = r.operation
|
||||
|
||||
assert r.size == 160
|
||||
assert op != 0 and bf_op_names[op] != "PAGE_MIGRATION_NONE"
|
||||
assert bf_op_names[op].lower().replace("page_migration_", "") in r.keys()
|
||||
|
||||
if "page_fault_start" in r:
|
||||
arg = r.page_fault_start
|
||||
assert arg.read_fault < 2
|
||||
validate_node(arg.agent_id, nodes)
|
||||
assert arg.address > 0
|
||||
|
||||
if "page_fault_end" in r:
|
||||
arg = r.page_fault_end
|
||||
assert arg.migrated < 2
|
||||
validate_node(arg.agent_id, nodes)
|
||||
assert arg.address > 0
|
||||
|
||||
if "page_migrate_start" in r:
|
||||
arg = r.page_migrate_start
|
||||
assert (
|
||||
0 < arg.start_addr < arg.end_addr
|
||||
), "Expected start addr to be less than end addr"
|
||||
if arg.start_addr == start_addr:
|
||||
assert arg.end_addr == end_addr
|
||||
validate_node(arg.from_agent, nodes)
|
||||
validate_node(arg.to_agent, nodes)
|
||||
validate_node(arg.prefetch_agent, nodes)
|
||||
validate_node(arg.preferred_agent, nodes)
|
||||
assert 0 <= arg.trigger < 4
|
||||
|
||||
if "page_migrate_end" in r:
|
||||
arg = r.page_migrate_end
|
||||
assert (
|
||||
0 < arg.start_addr < arg.end_addr
|
||||
), "Expected start addr to be less than end addr"
|
||||
if arg.start_addr == start_addr:
|
||||
assert arg.end_addr == end_addr
|
||||
validate_node(arg.from_agent, nodes)
|
||||
validate_node(arg.to_agent, nodes)
|
||||
assert 0 <= arg.trigger < 4
|
||||
|
||||
if "queue_eviction" in r:
|
||||
arg = r.queue_eviction
|
||||
validate_node(arg.agent_id, nodes)
|
||||
assert 0 <= arg.trigger < 6
|
||||
|
||||
if "queue_restore" in r:
|
||||
arg = r.queue_restore
|
||||
assert arg.rescheduled < 2
|
||||
validate_node(arg.agent_id, nodes)
|
||||
|
||||
if "unmap_from_gpu" in r:
|
||||
arg = r.unmap_from_gpu
|
||||
assert (
|
||||
0 < arg.start_addr < arg.end_addr
|
||||
), "Expected start addr to be less than end addr"
|
||||
if arg.start_addr == start_addr:
|
||||
assert arg.end_addr == end_addr
|
||||
validate_node(arg.agent_id, nodes)
|
||||
assert 0 <= arg.trigger < 3
|
||||
|
||||
if "dropped_event" in r:
|
||||
arg = r.dropped_event
|
||||
# We shouldn't get any dropped events. If we do, our test needs to be redesigned.
|
||||
assert arg.dropped_events_count == 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
exit_code = pytest.main(["-x", __file__] + sys.argv[1:])
|
||||
sys.exit(exit_code)
|
||||
@@ -903,7 +903,6 @@ auto memory_copy_bf_records = std::deque<rocprofiler_buffer_tracing_memory_c
|
||||
auto memory_allocation_bf_records =
|
||||
std::deque<rocprofiler_buffer_tracing_memory_allocation_record_t>{};
|
||||
auto scratch_memory_records = std::deque<rocprofiler_buffer_tracing_scratch_memory_record_t>{};
|
||||
auto page_migration_records = std::deque<rocprofiler_buffer_tracing_page_migration_record_t>{};
|
||||
auto corr_id_retire_records =
|
||||
std::deque<rocprofiler_buffer_tracing_correlation_id_retirement_record_t>{};
|
||||
auto rccl_api_bf_records = std::deque<rocprofiler_buffer_tracing_rccl_api_record_t>{};
|
||||
@@ -912,6 +911,18 @@ auto rocdecode_api_ext_bf_records =
|
||||
std::deque<rocprofiler_buffer_tracing_rocdecode_api_ext_record_t>{};
|
||||
auto rocjpeg_api_bf_records = std::deque<rocprofiler_buffer_tracing_rocjpeg_api_record_t>{};
|
||||
auto ompt_bf_records = std::deque<rocprofiler_buffer_tracing_ompt_record_t>{};
|
||||
auto kfd_page_migrate_event_records =
|
||||
std::deque<rocprofiler_buffer_tracing_kfd_event_page_migrate_record_t>{};
|
||||
auto kfd_page_fault_event_records =
|
||||
std::deque<rocprofiler_buffer_tracing_kfd_event_page_fault_record_t>{};
|
||||
auto kfd_queue_event_records = std::deque<rocprofiler_buffer_tracing_kfd_event_queue_record_t>{};
|
||||
auto kfd_unmap_from_gpu_event_records =
|
||||
std::deque<rocprofiler_buffer_tracing_kfd_event_unmap_from_gpu_record_t>{};
|
||||
auto kfd_dropped_events_event_records =
|
||||
std::deque<rocprofiler_buffer_tracing_kfd_event_dropped_events_record_t>{};
|
||||
auto kfd_page_migrate_records = std::deque<rocprofiler_buffer_tracing_kfd_page_migrate_record_t>{};
|
||||
auto kfd_page_fault_records = std::deque<rocprofiler_buffer_tracing_kfd_page_fault_record_t>{};
|
||||
auto kfd_queue_records = std::deque<rocprofiler_buffer_tracing_kfd_queue_record_t>{};
|
||||
|
||||
void
|
||||
tool_tracing_buffered(rocprofiler_context_id_t /*context*/,
|
||||
@@ -1002,13 +1013,6 @@ tool_tracing_buffered(rocprofiler_context_id_t /*context*/,
|
||||
|
||||
scratch_memory_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_PAGE_MIGRATION)
|
||||
{
|
||||
auto* record = static_cast<rocprofiler_buffer_tracing_page_migration_record_t*>(
|
||||
header->payload);
|
||||
|
||||
page_migration_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT)
|
||||
{
|
||||
auto* record =
|
||||
@@ -1060,6 +1064,66 @@ tool_tracing_buffered(rocprofiler_context_id_t /*context*/,
|
||||
|
||||
rocjpeg_api_bf_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_EVENT_PAGE_MIGRATE)
|
||||
{
|
||||
auto* record =
|
||||
static_cast<rocprofiler_buffer_tracing_kfd_event_page_migrate_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_page_migrate_event_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_EVENT_PAGE_FAULT)
|
||||
{
|
||||
auto* record =
|
||||
static_cast<rocprofiler_buffer_tracing_kfd_event_page_fault_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_page_fault_event_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_EVENT_QUEUE)
|
||||
{
|
||||
auto* record = static_cast<rocprofiler_buffer_tracing_kfd_event_queue_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_queue_event_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_EVENT_UNMAP_FROM_GPU)
|
||||
{
|
||||
auto* record =
|
||||
static_cast<rocprofiler_buffer_tracing_kfd_event_unmap_from_gpu_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_unmap_from_gpu_event_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_EVENT_DROPPED_EVENTS)
|
||||
{
|
||||
auto* record =
|
||||
static_cast<rocprofiler_buffer_tracing_kfd_event_dropped_events_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_dropped_events_event_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_PAGE_MIGRATE)
|
||||
{
|
||||
auto* record = static_cast<rocprofiler_buffer_tracing_kfd_page_migrate_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_page_migrate_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_PAGE_FAULT)
|
||||
{
|
||||
auto* record = static_cast<rocprofiler_buffer_tracing_kfd_page_fault_record_t*>(
|
||||
header->payload);
|
||||
|
||||
kfd_page_fault_records.emplace_back(*record);
|
||||
}
|
||||
else if(header->kind == ROCPROFILER_BUFFER_TRACING_KFD_QUEUE)
|
||||
{
|
||||
auto* record =
|
||||
static_cast<rocprofiler_buffer_tracing_kfd_queue_record_t*>(header->payload);
|
||||
|
||||
kfd_queue_records.emplace_back(*record);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error{
|
||||
@@ -1155,7 +1219,6 @@ rocprofiler_context_id_t scratch_memory_ctx = {0};
|
||||
rocprofiler_context_id_t corr_id_retire_ctx = {0};
|
||||
rocprofiler_context_id_t kernel_dispatch_callback_ctx = {0};
|
||||
rocprofiler_context_id_t kernel_dispatch_buffered_ctx = {0};
|
||||
rocprofiler_context_id_t page_migration_ctx = {0};
|
||||
rocprofiler_context_id_t runtime_init_callback_ctx = {};
|
||||
rocprofiler_context_id_t runtime_init_buffered_ctx = {};
|
||||
rocprofiler_context_id_t rocdecode_api_callback_ctx = {0};
|
||||
@@ -1163,24 +1226,39 @@ rocprofiler_context_id_t rocdecode_api_buffered_ctx = {0};
|
||||
rocprofiler_context_id_t rocdecode_api_ext_buffered_ctx = {0};
|
||||
rocprofiler_context_id_t rocjpeg_api_callback_ctx = {0};
|
||||
rocprofiler_context_id_t rocjpeg_api_buffered_ctx = {0};
|
||||
rocprofiler_context_id_t page_migrate_event_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_page_fault_event_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_queue_event_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_unmap_from_gpu_event_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_droped_events_event_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_page_migrate_records_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_page_fault_records_ctx = {0};
|
||||
rocprofiler_context_id_t kfd_queue_records_ctx = {0};
|
||||
|
||||
// buffers
|
||||
rocprofiler_buffer_id_t runtime_init_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t hsa_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t hip_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t marker_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t kernel_dispatch_buffer = {};
|
||||
rocprofiler_buffer_id_t memory_copy_buffer = {};
|
||||
rocprofiler_buffer_id_t memory_allocation_buffer = {};
|
||||
rocprofiler_buffer_id_t page_migration_buffer = {};
|
||||
rocprofiler_buffer_id_t counter_collection_buffer = {};
|
||||
rocprofiler_buffer_id_t scratch_memory_buffer = {};
|
||||
rocprofiler_buffer_id_t corr_id_retire_buffer = {};
|
||||
rocprofiler_buffer_id_t rccl_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t rocdecode_api_buffer = {};
|
||||
rocprofiler_buffer_id_t rocdecode_api_ext_buffer = {};
|
||||
rocprofiler_buffer_id_t rocjpeg_api_buffer = {};
|
||||
rocprofiler_buffer_id_t ompt_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t runtime_init_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t hsa_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t hip_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t marker_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t kernel_dispatch_buffer = {};
|
||||
rocprofiler_buffer_id_t memory_copy_buffer = {};
|
||||
rocprofiler_buffer_id_t memory_allocation_buffer = {};
|
||||
rocprofiler_buffer_id_t counter_collection_buffer = {};
|
||||
rocprofiler_buffer_id_t scratch_memory_buffer = {};
|
||||
rocprofiler_buffer_id_t corr_id_retire_buffer = {};
|
||||
rocprofiler_buffer_id_t rccl_api_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t rocdecode_api_buffer = {};
|
||||
rocprofiler_buffer_id_t rocdecode_api_ext_buffer = {};
|
||||
rocprofiler_buffer_id_t rocjpeg_api_buffer = {};
|
||||
rocprofiler_buffer_id_t ompt_buffered_buffer = {};
|
||||
rocprofiler_buffer_id_t page_migrate_event_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_page_fault_event_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_queue_event_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_unmap_from_gpu_event_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_droped_events_event_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_page_migrate_records_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_page_fault_records_buffer = {};
|
||||
rocprofiler_buffer_id_t kfd_queue_records_buffer = {};
|
||||
|
||||
auto contexts = std::unordered_map<std::string_view, rocprofiler_context_id_t*>{
|
||||
{"RUNTIME_INIT_CALLBACK", &runtime_init_callback_ctx},
|
||||
@@ -1200,7 +1278,6 @@ auto contexts = std::unordered_map<std::string_view, rocprofiler_context_id_t*>{
|
||||
{"KERNEL_DISPATCH_BUFFERED", &kernel_dispatch_buffered_ctx},
|
||||
{"MEMORY_COPY_BUFFERED", &memory_copy_buffered_ctx},
|
||||
{"MEMORY_ALLOCATION_BUFFERED", &memory_allocation_buffered_ctx},
|
||||
{"PAGE_MIGRATION", &page_migration_ctx},
|
||||
{"COUNTER_COLLECTION", &counter_collection_ctx},
|
||||
{"SCRATCH_MEMORY", &scratch_memory_ctx},
|
||||
{"CORRELATION_ID_RETIREMENT", &corr_id_retire_ctx},
|
||||
@@ -1211,9 +1288,17 @@ auto contexts = std::unordered_map<std::string_view, rocprofiler_context_id_t*>{
|
||||
{"ROCJPEG_API_CALLBACK", &rocjpeg_api_callback_ctx},
|
||||
{"ROCJPEG_API_BUFFERED", &rocjpeg_api_buffered_ctx},
|
||||
{"OMPT_BUFFERED", &ompt_buffered_ctx},
|
||||
{"KFD_EVENT_PAGE_MIGRATE", &page_migrate_event_ctx},
|
||||
{"KFD_EVENT_PAGE_FAULT", &kfd_page_fault_event_ctx},
|
||||
{"KFD_EVENT_QUEUE", &kfd_queue_event_ctx},
|
||||
{"KFD_EVENT_UNMAP_FROM_GPU", &kfd_unmap_from_gpu_event_ctx},
|
||||
{"KFD_DROPPED_EVENTS", &kfd_droped_events_event_ctx},
|
||||
{"KFD_PAGE_MIGRATE", &kfd_page_migrate_records_ctx},
|
||||
{"KFD_PAGE_FAULT", &kfd_page_fault_records_ctx},
|
||||
{"KFD_QUEUE", &kfd_queue_records_ctx},
|
||||
};
|
||||
|
||||
auto buffers = std::array<rocprofiler_buffer_id_t*, 16>{&runtime_init_buffered_buffer,
|
||||
auto buffers = std::array<rocprofiler_buffer_id_t*, 22>{&runtime_init_buffered_buffer,
|
||||
&hsa_api_buffered_buffer,
|
||||
&hip_api_buffered_buffer,
|
||||
&marker_api_buffered_buffer,
|
||||
@@ -1221,22 +1306,28 @@ auto buffers = std::array<rocprofiler_buffer_id_t*, 16>{&runtime_init_buffered_b
|
||||
&memory_copy_buffer,
|
||||
&memory_allocation_buffer,
|
||||
&scratch_memory_buffer,
|
||||
&page_migration_buffer,
|
||||
&counter_collection_buffer,
|
||||
&corr_id_retire_buffer,
|
||||
&rccl_api_buffered_buffer,
|
||||
&ompt_buffered_buffer,
|
||||
&rocdecode_api_buffer,
|
||||
&rocdecode_api_ext_buffer,
|
||||
&rocjpeg_api_buffer};
|
||||
&rocjpeg_api_buffer,
|
||||
&kfd_page_fault_event_buffer,
|
||||
&kfd_queue_event_buffer,
|
||||
&kfd_unmap_from_gpu_event_buffer,
|
||||
&kfd_droped_events_event_buffer,
|
||||
&kfd_page_migrate_records_buffer,
|
||||
&kfd_page_fault_records_buffer,
|
||||
&kfd_queue_records_buffer};
|
||||
|
||||
auto agents = std::vector<rocprofiler_agent_t>{};
|
||||
auto agents_map = std::unordered_map<rocprofiler_agent_id_t, rocprofiler_agent_t>{};
|
||||
|
||||
rocprofiler_timestamp_t init_time = 0;
|
||||
rocprofiler_timestamp_t fini_time = 0;
|
||||
rocprofiler_thread_id_t main_tid = 0;
|
||||
auto page_migration_status = ROCPROFILER_STATUS_SUCCESS;
|
||||
rocprofiler_timestamp_t init_time = 0;
|
||||
rocprofiler_timestamp_t fini_time = 0;
|
||||
rocprofiler_thread_id_t main_tid = 0;
|
||||
auto kfd_configure_status = ROCPROFILER_STATUS_SUCCESS;
|
||||
|
||||
int
|
||||
tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
|
||||
@@ -1505,15 +1596,6 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
|
||||
&scratch_memory_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(page_migration_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&page_migration_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(corr_id_retire_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
@@ -1576,6 +1658,78 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
|
||||
&ompt_buffered_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(page_migrate_event_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&page_migrate_event_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_page_fault_event_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_page_fault_event_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_queue_event_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_queue_event_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_unmap_from_gpu_event_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_unmap_from_gpu_event_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_droped_events_event_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_droped_events_event_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_page_migrate_records_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_page_migrate_records_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_page_fault_records_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_page_fault_records_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_create_buffer(kfd_queue_records_ctx,
|
||||
buffer_size,
|
||||
watermark,
|
||||
ROCPROFILER_BUFFER_POLICY_LOSSLESS,
|
||||
tool_tracing_buffered,
|
||||
tool_data,
|
||||
&kfd_queue_records_buffer),
|
||||
"buffer creation");
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_configure_buffer_tracing_service(
|
||||
runtime_init_buffered_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_RUNTIME_INITIALIZATION,
|
||||
@@ -1667,20 +1821,139 @@ tool_init(rocprofiler_client_finalize_t fini_func, void* tool_data)
|
||||
"buffer tracing service for scratch memory configure");
|
||||
|
||||
{
|
||||
page_migration_status =
|
||||
rocprofiler_configure_buffer_tracing_service(page_migration_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_PAGE_MIGRATION,
|
||||
nullptr,
|
||||
0,
|
||||
page_migration_buffer);
|
||||
kfd_configure_status = rocprofiler_configure_buffer_tracing_service(
|
||||
page_migrate_event_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_EVENT_PAGE_MIGRATE,
|
||||
nullptr,
|
||||
0,
|
||||
page_migrate_event_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(page_migration_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(page_migration_status)
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(page_migration_status, message);
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status = rocprofiler_configure_buffer_tracing_service(
|
||||
kfd_page_fault_event_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_EVENT_PAGE_FAULT,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_page_fault_event_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status =
|
||||
rocprofiler_configure_buffer_tracing_service(kfd_queue_event_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_EVENT_QUEUE,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_queue_event_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status = rocprofiler_configure_buffer_tracing_service(
|
||||
kfd_unmap_from_gpu_event_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_EVENT_UNMAP_FROM_GPU,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_unmap_from_gpu_event_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status = rocprofiler_configure_buffer_tracing_service(
|
||||
kfd_droped_events_event_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_EVENT_DROPPED_EVENTS,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_droped_events_event_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status = rocprofiler_configure_buffer_tracing_service(
|
||||
kfd_page_migrate_records_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_PAGE_MIGRATE,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_page_migrate_records_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status =
|
||||
rocprofiler_configure_buffer_tracing_service(kfd_page_fault_records_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_PAGE_FAULT,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_page_fault_records_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
{
|
||||
kfd_configure_status =
|
||||
rocprofiler_configure_buffer_tracing_service(kfd_queue_records_ctx,
|
||||
ROCPROFILER_BUFFER_TRACING_KFD_QUEUE,
|
||||
nullptr,
|
||||
0,
|
||||
kfd_queue_records_buffer);
|
||||
|
||||
constexpr auto message = "buffer tracing service for page migration configure";
|
||||
if(kfd_configure_status == ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL)
|
||||
std::cerr << message
|
||||
<< " failed: " << rocprofiler_get_status_string(kfd_configure_status)
|
||||
<< std::endl;
|
||||
else
|
||||
ROCPROFILER_CALL(kfd_configure_status, message);
|
||||
}
|
||||
|
||||
ROCPROFILER_CALL(rocprofiler_configure_buffer_tracing_service(
|
||||
@@ -1883,7 +2156,14 @@ tool_fini(void* tool_data)
|
||||
<< ", memory_copy_bf_records=" << memory_copy_bf_records.size()
|
||||
<< ", memory_allocation_bf_records=" << memory_allocation_bf_records.size()
|
||||
<< ", scratch_memory_records=" << scratch_memory_records.size()
|
||||
<< ", page_migration=" << page_migration_records.size()
|
||||
<< ", kfd_page_migrate_event=" << kfd_page_migrate_event_records.size()
|
||||
<< ", kfd_page_fault_event=" << kfd_page_fault_event_records.size()
|
||||
<< ", kfd_queue_event=" << kfd_queue_event_records.size()
|
||||
<< ", kfd_unmap_from_gpu_event=" << kfd_unmap_from_gpu_event_records.size()
|
||||
<< ", kfd_droped_events_event=" << kfd_dropped_events_event_records.size()
|
||||
<< ", kfd_page_migrate_record=" << kfd_page_migrate_records.size()
|
||||
<< ", kfd_page_fault_record=" << kfd_page_fault_records.size()
|
||||
<< ", kfd_queue_record=" << kfd_queue_records.size()
|
||||
<< ", runtime_init_bf_records=" << runtime_init_bf_records.size()
|
||||
<< ", hsa_api_bf_records=" << hsa_api_bf_records.size()
|
||||
<< ", hip_api_bf_records=" << hip_api_bf_records.size()
|
||||
@@ -1955,8 +2235,8 @@ write_json(call_stack_t* _call_stack)
|
||||
auto json_ar = JSONOutputArchive{*ofs, json_opts};
|
||||
auto buffer_names = sdk::get_buffer_tracing_names();
|
||||
auto callbk_names = sdk::get_callback_tracing_names();
|
||||
auto validate_page_migration =
|
||||
(page_migration_status != ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL);
|
||||
auto validate_kfd_events =
|
||||
(kfd_configure_status != ROCPROFILER_STATUS_ERROR_INCOMPATIBLE_KERNEL);
|
||||
|
||||
json_ar.setNextName("rocprofiler-sdk-json-tool");
|
||||
json_ar.startNode();
|
||||
@@ -1967,7 +2247,7 @@ write_json(call_stack_t* _call_stack)
|
||||
json_ar(cereal::make_nvp("main_tid", main_tid));
|
||||
json_ar(cereal::make_nvp("init_time", init_time));
|
||||
json_ar(cereal::make_nvp("fini_time", fini_time));
|
||||
json_ar(cereal::make_nvp("validate_page_migration", validate_page_migration));
|
||||
json_ar(cereal::make_nvp("validate_kfd_events", validate_kfd_events));
|
||||
json_ar.finishNode();
|
||||
|
||||
json_ar(cereal::make_nvp("agents", agents));
|
||||
@@ -2012,7 +2292,15 @@ write_json(call_stack_t* _call_stack)
|
||||
json_ar(cereal::make_nvp("memory_copies", memory_copy_bf_records));
|
||||
json_ar(cereal::make_nvp("memory_allocations", memory_allocation_bf_records));
|
||||
json_ar(cereal::make_nvp("scratch_memory_traces", scratch_memory_records));
|
||||
json_ar(cereal::make_nvp("page_migration", page_migration_records));
|
||||
json_ar(cereal::make_nvp("kfd_page_migrate_events", kfd_page_migrate_event_records));
|
||||
json_ar(cereal::make_nvp("kfd_page_fault_events", kfd_page_fault_event_records));
|
||||
json_ar(cereal::make_nvp("kfd_queue_events", kfd_queue_event_records));
|
||||
json_ar(
|
||||
cereal::make_nvp("kfd_unmap_from_gpu_events", kfd_unmap_from_gpu_event_records));
|
||||
json_ar(cereal::make_nvp("kfd_droped_events", kfd_dropped_events_event_records));
|
||||
json_ar(cereal::make_nvp("kfd_page_migrate_records", kfd_page_migrate_records));
|
||||
json_ar(cereal::make_nvp("kfd_page_fault_records", kfd_page_fault_records));
|
||||
json_ar(cereal::make_nvp("kfd_queue_records", kfd_queue_records));
|
||||
json_ar(cereal::make_nvp("hsa_api_traces", hsa_api_bf_records));
|
||||
json_ar(cereal::make_nvp("hip_api_traces", hip_api_bf_records));
|
||||
json_ar(cereal::make_nvp("marker_api_traces", marker_api_bf_records));
|
||||
|
||||
Reference in New Issue
Block a user