Jonathan R. Madsen
1bb94add11
* Fix HIP compiler iterate args
- `include/rocprofiler-sdk/hip/api_args.h`
- replace struct fields named "f" with "func"
- replace hip stream fields named "hStream" with "stream"
- `lib/rocprofiler-sdk/callback_tracing.cpp`
- iterate_args for HIP compiler table
- `lib/rocprofiler-sdk/registration.cpp`
- fix warning about roctx num_tables
- `lib/rocprofiler-sdk/hip/hip.def.cpp`
- replace struct fields named "f" with "func"
- replace hip stream fields named "hStream" with "stream"
- `lib/rocprofiler-sdk/{hip,hsa,marker}/utils.hpp`
- improve `stringize_impl`
- `lib/rocprofiler-sdk/hsa/code_object.cpp`
- remove stale commented out code
- `lib/rocprofiler-sdk/hsa/queue_controller.*`
- destory_queue -> destroy_queue
- `tests/tools/json-tool.cpp`
- improve parallelism in tool_tracing_callback
- serialize the marker api args
- only invoke rocprofiler_iterate_callback_tracing_kind_operation_args in exit phase
- `samples/counter_collection/CMakeLists.txt`
- reduce timeout on tests to 120 seconds
* Update lib/rocprofiler-sdk/hsa/utils.hpp
- disable dereference of double pointer in stringize_impl
* Update lib/common
- indirection_level in mpl.hpp
- stringize_arg.hpp
* Rework rocprofiler_iterate_callback_tracing_kind_operation_args
- provide more information in rocprofiler_callback_tracing_operation_args_cb_t
- support specifying the dereference level to account for output paramters
221 lines
20 KiB
C++
221 lines
20 KiB
C++
// MIT License
|
|
//
|
|
// Copyright (c) 2023 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
#pragma once
|
|
|
|
#include "lib/common/defines.hpp"
|
|
|
|
#define HIP_API_INFO_DEFINITION_0(HIP_TABLE, HIP_API_ID, HIP_FUNC, HIP_FUNC_PTR) \
|
|
namespace rocprofiler \
|
|
{ \
|
|
namespace hip \
|
|
{ \
|
|
template <> \
|
|
struct hip_api_info<HIP_TABLE, HIP_API_ID> : hip_domain_info<HIP_TABLE> \
|
|
{ \
|
|
static constexpr auto table_idx = HIP_TABLE; \
|
|
static constexpr auto operation_idx = HIP_API_ID; \
|
|
static constexpr auto name = #HIP_FUNC; \
|
|
\
|
|
using domain_type = hip_domain_info<table_idx>; \
|
|
using this_type = hip_api_info<table_idx, operation_idx>; \
|
|
using base_type = hip_api_impl<table_idx, operation_idx>; \
|
|
\
|
|
using domain_type::callback_domain_idx; \
|
|
using domain_type::buffered_domain_idx; \
|
|
using domain_type::args_type; \
|
|
using domain_type::retval_type; \
|
|
using domain_type::callback_data_type; \
|
|
\
|
|
static constexpr auto offset() \
|
|
{ \
|
|
return offsetof(hip_table_lookup<table_idx>::type, HIP_FUNC_PTR); \
|
|
} \
|
|
\
|
|
static_assert(offsetof(hip_table_lookup<table_idx>::type, HIP_FUNC_PTR) == \
|
|
(sizeof(size_t) + (operation_idx * sizeof(void*))), \
|
|
"ABI error for " #HIP_FUNC); \
|
|
\
|
|
static auto& get_table() { return hip_table_lookup<table_idx>{}(); } \
|
|
\
|
|
template <typename TableT> \
|
|
static auto& get_table(TableT& _v) \
|
|
{ \
|
|
return hip_table_lookup<table_idx>{}(_v); \
|
|
} \
|
|
\
|
|
template <typename TableT> \
|
|
static auto& get_table_func(TableT& _table) \
|
|
{ \
|
|
if constexpr(std::is_pointer<TableT>::value) \
|
|
{ \
|
|
assert(_table != nullptr && "nullptr to HIP table for " #HIP_FUNC " function"); \
|
|
return _table->HIP_FUNC_PTR; \
|
|
} \
|
|
else \
|
|
{ \
|
|
return _table.HIP_FUNC_PTR; \
|
|
} \
|
|
} \
|
|
\
|
|
static auto& get_table_func() { return get_table_func(get_table()); } \
|
|
\
|
|
template <typename DataT> \
|
|
static auto& get_api_data_args(DataT& _data) \
|
|
{ \
|
|
return _data.HIP_FUNC; \
|
|
} \
|
|
\
|
|
template <typename RetT, typename... Args> \
|
|
static auto get_functor(RetT (*)(Args...)) \
|
|
{ \
|
|
if constexpr(std::is_void<RetT>::value) \
|
|
return [](Args... args) -> RetT { base_type::functor(args...); }; \
|
|
else \
|
|
return [](Args... args) -> RetT { return base_type::functor(args...); }; \
|
|
} \
|
|
\
|
|
static auto get_functor() { return get_functor(get_table_func()); } \
|
|
\
|
|
static std::vector<void*> as_arg_addr(callback_data_type) { return std::vector<void*>{}; } \
|
|
\
|
|
static std::vector<common::stringified_argument> as_arg_list(callback_data_type, int32_t) \
|
|
{ \
|
|
return {}; \
|
|
} \
|
|
}; \
|
|
} \
|
|
}
|
|
|
|
#define HIP_API_INFO_DEFINITION_V(HIP_TABLE, HIP_API_ID, HIP_FUNC, HIP_FUNC_PTR, ...) \
|
|
namespace rocprofiler \
|
|
{ \
|
|
namespace hip \
|
|
{ \
|
|
template <> \
|
|
struct hip_api_info<HIP_TABLE, HIP_API_ID> : hip_domain_info<HIP_TABLE> \
|
|
{ \
|
|
static constexpr auto table_idx = HIP_TABLE; \
|
|
static constexpr auto operation_idx = HIP_API_ID; \
|
|
static constexpr auto name = #HIP_FUNC; \
|
|
\
|
|
using domain_type = hip_domain_info<table_idx>; \
|
|
using this_type = hip_api_info<table_idx, operation_idx>; \
|
|
using base_type = hip_api_impl<table_idx, operation_idx>; \
|
|
\
|
|
static constexpr auto callback_domain_idx = domain_type::callback_domain_idx; \
|
|
static constexpr auto buffered_domain_idx = domain_type::buffered_domain_idx; \
|
|
\
|
|
using domain_type::args_type; \
|
|
using domain_type::retval_type; \
|
|
using domain_type::callback_data_type; \
|
|
\
|
|
static constexpr auto offset() \
|
|
{ \
|
|
return offsetof(hip_table_lookup<table_idx>::type, HIP_FUNC_PTR); \
|
|
} \
|
|
\
|
|
static_assert(offsetof(hip_table_lookup<table_idx>::type, HIP_FUNC_PTR) == \
|
|
(sizeof(size_t) + (operation_idx * sizeof(void*))), \
|
|
"ABI error for " #HIP_FUNC); \
|
|
\
|
|
static auto& get_table() { return hip_table_lookup<table_idx>{}(); } \
|
|
\
|
|
template <typename TableT> \
|
|
static auto& get_table(TableT& _v) \
|
|
{ \
|
|
return hip_table_lookup<table_idx>{}(_v); \
|
|
} \
|
|
\
|
|
template <typename TableT> \
|
|
static auto& get_table_func(TableT& _table) \
|
|
{ \
|
|
if constexpr(std::is_pointer<TableT>::value) \
|
|
{ \
|
|
assert(_table != nullptr && "nullptr to HIP table for " #HIP_FUNC " function"); \
|
|
return _table->HIP_FUNC_PTR; \
|
|
} \
|
|
else \
|
|
{ \
|
|
return _table.HIP_FUNC_PTR; \
|
|
} \
|
|
} \
|
|
\
|
|
static auto& get_table_func() { return get_table_func(get_table()); } \
|
|
\
|
|
template <typename DataT> \
|
|
static auto& get_api_data_args(DataT& _data) \
|
|
{ \
|
|
return _data.HIP_FUNC; \
|
|
} \
|
|
\
|
|
template <typename RetT, typename... Args> \
|
|
static auto get_functor(RetT (*)(Args...)) \
|
|
{ \
|
|
if constexpr(std::is_same<RetT, void>::value) \
|
|
return [](Args... args) -> RetT { base_type::functor(args...); }; \
|
|
else \
|
|
return [](Args... args) -> RetT { return base_type::functor(args...); }; \
|
|
} \
|
|
\
|
|
static auto get_functor() { return get_functor(get_table_func()); } \
|
|
\
|
|
static std::vector<void*> as_arg_addr(callback_data_type trace_data) \
|
|
{ \
|
|
return std::vector<void*>{ \
|
|
GET_ADDR_MEMBER_FIELDS(get_api_data_args(trace_data.args), __VA_ARGS__)}; \
|
|
} \
|
|
\
|
|
static auto as_arg_list(callback_data_type trace_data, int32_t max_deref) \
|
|
{ \
|
|
return utils::stringize( \
|
|
max_deref, \
|
|
GET_NAMED_MEMBER_FIELDS(get_api_data_args(trace_data.args), __VA_ARGS__)); \
|
|
} \
|
|
}; \
|
|
} \
|
|
}
|
|
|
|
#define HIP_API_TABLE_LOOKUP_DEFINITION(TABLE_ID, TYPE, MEMBER) \
|
|
namespace rocprofiler \
|
|
{ \
|
|
namespace hip \
|
|
{ \
|
|
template <> \
|
|
struct hip_table_lookup<TABLE_ID> \
|
|
{ \
|
|
using type = TYPE; \
|
|
auto& operator()(hip_api_table_t& _v) const { return _v.MEMBER; } \
|
|
auto& operator()(hip_api_table_t* _v) const { return _v->MEMBER; } \
|
|
auto& operator()(type& _v) const { return _v; } \
|
|
auto& operator()(type* _v) const { return *_v; } \
|
|
auto& operator()() const { return (*this)(get_table()); } \
|
|
}; \
|
|
\
|
|
template <> \
|
|
struct hip_table_id_lookup<TYPE> \
|
|
{ \
|
|
static constexpr auto value = TABLE_ID; \
|
|
}; \
|
|
} \
|
|
}
|