AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[SDK][rocprofv3] MI300 Stochastic PC sampling (#92)

Browse Source 
* MI300 Stochastic PC sampling SDK API implementation

* ROCProfV3: Stochastic PC sampling Support (#94)

* ROCProfV3: MI300 Stochastic PC sampling initial draft

* ROCProfV3: Initial Stochastic PC sampling Tests (#95)

ROCProfV3: Initial Stochastic PC sampling tests

* Update rocprofiler_pc_sampling_record_stochastic_v0_t

- update doxygen docs for members
- replace rocprofiler_correlation_id_t with rocprofiler_async_correlation_id_t

* Relax the check in JSON tests

* drain PC sampling buffer during finalize_rocprofv3

* Increase timeout for "Test Install Build" step

- 10 minutes -> 20 minutes
- "Test Installed Packages" has 20 minutes so "Test Install Build" should also

---------

Co-authored-by: Jonathan R. Madsen <jonathanrmadsen@gmail.com>
This commit is contained in:
Indic, Vladimir
2025-03-21 20:40:45 +01:00
committed by GitHub
parent c06feccf2a
commit 49ce79a5b5
98 changed files with 5266 additions and 1031 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/pc_sampling/address_translation.cpp
+14 -10
View File
@@ -44,14 +44,13 @@ namespace
{
struct FlatProfiler
{
public:
FlatProfiler() = default;
~FlatProfiler() = default;
CodeobjAddressTranslate translator;
KernelObjectMap kernel_object_map;
FlatProfile flat_profile;
std::mutex global_mut;
CodeobjAddressTranslate translator = {};
KernelObjectMap kernel_object_map = {};
FlatProfile flat_profile = {};
std::mutex global_mut = {};
};
} // namespace
@@ -68,6 +67,7 @@ void
fini()
{
delete flat_profiler;
flat_profiler = nullptr;
}
CodeobjAddressTranslate&
@@ -186,15 +186,19 @@ dump_flat_profile()
ss << "====================================\n" << std::endl;
});
ss << "The total number of decoded samples: " << samples_num << std::endl;
ss << "The total number of collected samples: " << client::pcs::total_samples_num()
ss << "The total number of valid decoded samples: "
<< flat_profile.get_valid_decoded_samples_num() << std::endl;
ss << "The total number of invalid samples : " << flat_profile.get_invalid_samples_num()
<< std::endl;
*utils::get_output_stream() << ss.str() << std::endl;
assert(samples_num == client::pcs::total_samples_num());
// We expect at least one PC sample to be decoded/delivered;
assert(samples_num > 0);
utils::pcs_assert(
samples_num == flat_profile.get_valid_decoded_samples_num(),
"Number of collected valid samples different than the number of decoded samples.");
utils::pcs_assert(samples_num > 0, "No valid samples collected/decoded.");
utils::pcs_assert(flat_profile.more_valid_decoded_samples_expected(),
"More invalid samples observed.");
}
} // namespace address_translation
tests/pc_sampling/address_translation.hpp
+38 -15
View File
@@ -25,6 +25,7 @@
#include <rocprofiler-sdk/cxx/codeobj/code_printing.hpp>
#include <algorithm>
#include <atomic>
#include <cassert>
#include <functional>
#include <map>
@@ -47,8 +48,8 @@ using marker_id_t = rocprofiler::sdk::codeobj::disassembly::marker_i
*/
struct inst_id_t
{
marker_id_t code_object_id;
uint64_t pc_addr;
marker_id_t code_object_id = 0;
uint64_t pc_addr = 0;
bool operator==(const inst_id_t& b) const
{
@@ -97,12 +98,12 @@ public:
uint64_t end_address() const { return end_address_; };
private:
mutable std::shared_mutex mut;
uint64_t code_object_id_;
std::string kernel_name_;
uint64_t begin_address_;
uint64_t end_address_;
std::vector<std::unique_ptr<Instruction>> instructions_;
mutable std::shared_mutex mut = {};
uint64_t code_object_id_ = 0;
std::string kernel_name_ = {};
uint64_t begin_address_ = 0;
uint64_t end_address_ = 0;
std::vector<std::unique_ptr<Instruction>> instructions_ = {};
};
class KernelObjectMap
@@ -156,8 +157,8 @@ public:
}
private:
std::unordered_map<std::string, std::unique_ptr<KernelObject>> kernel_object_map;
mutable std::shared_mutex mut;
std::unordered_map<std::string, std::unique_ptr<KernelObject>> kernel_object_map = {};
mutable std::shared_mutex mut = {};
std::string form_key(uint64_t code_object_id, std::string kernel_name, uint64_t begin_address)
{
@@ -206,14 +207,14 @@ public:
uint64_t sample_count() const { return sample_count_; };
private:
mutable std::shared_mutex mut;
mutable std::shared_mutex mut = {};
// FIXME: prevent direct access of the following fields.
// The following fields should be accessible only from within `process` function.
std::unique_ptr<Instruction> inst_;
std::unique_ptr<Instruction> inst_ = {};
// In case an instruction is samples with different exec masks,
// keep track of how many time each exec_mask was observed.
std::map<uint64_t, uint64_t> exec_mask_counts_;
std::map<uint64_t, uint64_t> exec_mask_counts_ = {};
// How many time this instruction is samples
uint64_t sample_count_ = 0;
};
@@ -226,6 +227,8 @@ public:
// write lock required
void add_sample(std::unique_ptr<Instruction> instruction, uint64_t exec_mask)
{
// counting valid decoded samples
valid_decoded_samples_num++;
auto lock = std::unique_lock{mut};
inst_id_t inst_id = {.code_object_id = instruction->codeobj_id,
@@ -256,10 +259,30 @@ public:
return nullptr;
}
void add_invalid_sample()
{
// counting invalid samples
invalid_decoded_samples_num++;
}
/**
* @brief Verify that more valid decoded samples is generated.
*/
bool more_valid_decoded_samples_expected() const
{
return valid_decoded_samples_num > invalid_decoded_samples_num;
}
uint64_t get_valid_decoded_samples_num() const { return valid_decoded_samples_num; }
uint64_t get_invalid_samples_num() const { return invalid_decoded_samples_num; }
private:
// TODO: optimize to use unordered_map
std::map<inst_id_t, std::unique_ptr<SampleInstruction>> samples;
mutable std::shared_mutex mut;
std::map<inst_id_t, std::unique_ptr<SampleInstruction>> samples = {};
std::atomic<uint64_t> valid_decoded_samples_num = {};
std::atomic<uint64_t> invalid_decoded_samples_num = {};
mutable std::shared_mutex mut = {};
};
std::mutex&
tests/pc_sampling/pcs.cpp
+155 -68
View File
@@ -53,6 +53,11 @@ using avail_configs_vec_t = std::vector<rocprofiler_pc_sampling_configur
using tool_agent_info_vec_t = std::vector<std::unique_ptr<tool_agent_info>>;
using pc_sampling_buffer_id_vec_t = std::vector<rocprofiler_buffer_id_t>;
namespace
{
constexpr uint64_t stochastic_interval = 1048576; // 2 ^ 20 cycles
} // namespace
struct tool_agent_info
{
rocprofiler_agent_id_t agent_id;
@@ -79,16 +84,14 @@ public:
}
// GPU agents supporting PC sampling
tool_agent_info_vec_t gpu_agents;
// The total number of collected samples
std::atomic<uint64_t> total_samples_num{0};
tool_agent_info_vec_t gpu_agents = {};
// ROCProfiler-SDK PC sampling buffers
pc_sampling_buffer_id_vec_t buffer_ids;
pc_sampling_buffer_id_vec_t buffer_ids = {};
// The set that keeps track of reported code object loading/unloading events.
// At the end of the test, the sets needs to be empty.
// Namely, each loading event will insert a code object id into the set,
// while each unloading event will delete a code ojbect id from the set.
code_object_id_set_t active_code_objects;
code_object_id_set_t active_code_objects = {};
};
// The reason for using raw pointers is the following.
@@ -139,7 +142,7 @@ find_all_gpu_agents_supporting_pc_sampling_impl(rocprofiler_agent_version_t vers
<< "type=" << _agents[i]->type << "\n";
}
*utils::get_output_stream() << ss.str() << std::endl;
*utils::get_output_stream() << ss.str() << "\n";
return ROCPROFILER_STATUS_SUCCESS;
}
@@ -188,8 +191,8 @@ query_avail_configs_for_agent(tool_agent_info* agent_info)
{
// The query operation failed, so consider the PC sampling is unsupported at the agent.
// This can happen if the PC sampling service is invoked within the ROCgdb.
ss << "Querying PC sampling capabilities failed with status: " << status << std::endl;
*utils::get_output_stream() << ss.str() << std::endl;
ss << "Querying PC sampling capabilities failed with status: " << status << "\n";
*utils::get_output_stream() << ss.str() << "\n";
return false;
}
else if(agent_info->avail_configs->size() == 0)
@@ -199,7 +202,8 @@ query_avail_configs_for_agent(tool_agent_info* agent_info)
}
ss << "The agent with the id: " << agent_info->agent_id.handle << " supports the "
<< agent_info->avail_configs->size() << " configurations: " << std::endl;
<< agent_info->avail_configs->size() << " configurations: "
<< "\n";
size_t ind = 0;
for(auto& cfg : *agent_info->avail_configs)
{
@@ -208,7 +212,11 @@ query_avail_configs_for_agent(tool_agent_info* agent_info)
<< "unit: " << cfg.unit << ", "
<< "min_interval: " << cfg.min_interval << ", "
<< "max_interval: " << cfg.max_interval << ", "
<< "flags: " << std::hex << cfg.flags << std::dec << std::endl;
<< "flags: " << std::hex << cfg.flags << std::dec
<< ((cfg.flags == ROCPROFILER_PC_SAMPLING_CONFIGURATION_FLAGS_INTERVAL_POW2)
? " (an interval value must be power of 2)"
: "")
<< "\n";
}
*utils::get_output_stream() << ss.str() << std::flush;
@@ -221,8 +229,9 @@ configure_pc_sampling_prefer_stochastic(tool_agent_info* agent_info,
rocprofiler_context_id_t context_id,
rocprofiler_buffer_id_t buffer_id)
{
int failures = MAX_FAILURES;
size_t interval = 0;
auto stochastic_picked = false;
int failures = MAX_FAILURES;
size_t interval = 0;
do
{
// Update the list of available configurations
@@ -245,9 +254,9 @@ configure_pc_sampling_prefer_stochastic(tool_agent_info* agent_info,
{
if(cfg.method == ROCPROFILER_PC_SAMPLING_METHOD_STOCHASTIC)
{
// Temporarily disable stochastic sampling as it's not fully supported.
// first_stochastic_config = &cfg;
// break;
first_stochastic_config = &cfg;
stochastic_picked = true;
break;
}
else if(!first_host_trap_config &&
cfg.method == ROCPROFILER_PC_SAMPLING_METHOD_HOST_TRAP)
@@ -260,7 +269,7 @@ configure_pc_sampling_prefer_stochastic(tool_agent_info* agent_info,
const rocprofiler_pc_sampling_configuration_t* picked_cfg =
(first_stochastic_config != nullptr) ? first_stochastic_config : first_host_trap_config;
interval = picked_cfg->min_interval;
interval = (stochastic_picked) ? stochastic_interval : picked_cfg->min_interval;
auto status = rocprofiler_configure_pc_sampling_service(context_id,
agent_info->agent_id,
@@ -272,8 +281,10 @@ configure_pc_sampling_prefer_stochastic(tool_agent_info* agent_info,
if(status == ROCPROFILER_STATUS_SUCCESS)
{
*utils::get_output_stream()
<< ">>> We chose PC sampling interval: " << interval
<< " on the agent: " << agent_info->agent->id.handle << std::endl;
<< ">>> We chose " << (stochastic_picked ? "stochastic" : "Host-Trap")
<< " PC sampling with the interval: " << interval << " "
<< (stochastic_picked ? "clock-cycles" : "micro seconds")
<< " on the agent: " << agent_info->agent->id.handle << "\n";
return;
}
else if(status != ROCPROFILER_STATUS_ERROR_NOT_AVAILABLE)
@@ -301,6 +312,106 @@ configure_pc_sampling_prefer_stochastic(tool_agent_info* agent_info,
"Failed too many times configuring PC sampling service");
}
template <typename PcSamplingRecordT>
void
print_sample_common_fields(std::ostream& os, const PcSamplingRecordT* pc_sample)
{
os << "(code_obj_id, offset): (" << pc_sample->pc.code_object_id << ", 0x" << std::hex
<< pc_sample->pc.code_object_offset << "), "
<< "timestamp: " << std::dec << pc_sample->timestamp << ", "
<< "exec: " << std::hex << std::setw(16) << pc_sample->exec_mask << ", "
<< "workgroup_id_(x=" << std::dec << std::setw(5) << pc_sample->workgroup_id.x << ", "
<< "y=" << std::setw(5) << pc_sample->workgroup_id.y << ", "
<< "z=" << std::setw(5) << pc_sample->workgroup_id.z << "), "
<< "wave_in_group: " << std::setw(2) << static_cast<unsigned int>(pc_sample->wave_in_group)
<< ", "
<< "chiplet: " << std::setw(2) << static_cast<unsigned int>(pc_sample->hw_id.chiplet) << ", "
<< "dispatch_id: " << std::setw(7) << pc_sample->dispatch_id << ","
<< "correlation: {internal=" << std::setw(7) << pc_sample->correlation_id.internal << ", "
<< "external=" << std::setw(5) << pc_sample->correlation_id.external.value << "}, ";
}
void
print_sample(std::ostream& os, const rocprofiler_pc_sampling_record_host_trap_v0_t* sample)
{
print_sample_common_fields(os, sample);
os << "\n";
}
void
print_sample(std::ostream& os, const rocprofiler_pc_sampling_record_stochastic_v0_t* sample)
{
print_sample_common_fields(os, sample);
if(sample->wave_issued)
{
auto* inst_c_str = rocprofiler_get_pc_sampling_instruction_type_name(
static_cast<rocprofiler_pc_sampling_instruction_type_t>(sample->inst_type));
utils::pcs_assert(inst_c_str != nullptr, "Invalid instruction type");
os << "wave issued " << std::string(inst_c_str) << " instruction, ";
}
else
{
auto* reason_c_str = rocprofiler_get_pc_sampling_instruction_not_issued_reason_name(
static_cast<rocprofiler_pc_sampling_instruction_not_issued_reason_t>(
sample->snapshot.reason_not_issued));
utils::pcs_assert(reason_c_str != nullptr, "Invalid not issued reason");
os << "wave is stalled due to: " << std::string(reason_c_str) << " reason, ";
}
auto snapshot = sample->snapshot;
os << "two VALU instructions issued: " << static_cast<unsigned int>(snapshot.dual_issue_valu)
<< ", ";
os << "arbiter state: {pipe issued: ("
<< "VALU: " << static_cast<unsigned int>(snapshot.arb_state_issue_valu) << ", "
<< "MATRIX: " << static_cast<unsigned int>(snapshot.arb_state_issue_matrix) << ", "
<< "LDS: " << static_cast<unsigned int>(snapshot.arb_state_issue_lds) << ", "
<< "LDS_DIRECT: " << static_cast<unsigned int>(snapshot.arb_state_issue_lds_direct) << ", "
<< "SCALAR: " << static_cast<unsigned int>(snapshot.arb_state_issue_scalar) << ", "
<< "TEX: " << static_cast<unsigned int>(snapshot.arb_state_issue_vmem_tex) << ", "
<< "FLAT: " << static_cast<unsigned int>(snapshot.arb_state_issue_flat) << ", "
<< "EXPORT: " << static_cast<unsigned int>(snapshot.arb_state_issue_exp) << ", "
<< "MISC: " << static_cast<unsigned int>(snapshot.arb_state_issue_misc) << "), "
<< "pipe stalled: ("
<< "VALU: " << static_cast<unsigned int>(snapshot.arb_state_stall_valu) << ", "
<< "MATRIX: " << static_cast<unsigned int>(snapshot.arb_state_stall_matrix) << ", "
<< "LDS: " << static_cast<unsigned int>(snapshot.arb_state_stall_lds) << ", "
<< "LDS_DIRECT: " << static_cast<unsigned int>(snapshot.arb_state_stall_lds_direct) << ", "
<< "SCALAR: " << static_cast<unsigned int>(snapshot.arb_state_stall_scalar) << ", "
<< "TEX: " << static_cast<unsigned int>(snapshot.arb_state_stall_vmem_tex) << ", "
<< "FLAT: " << static_cast<unsigned int>(snapshot.arb_state_stall_flat) << ", "
<< "EXPORT: " << static_cast<unsigned int>(snapshot.arb_state_stall_exp) << ", "
<< "MISC: " << static_cast<unsigned int>(snapshot.arb_state_stall_misc) << ")}";
os << "\n";
}
template <typename PcSamplingRecordT>
static inline void
process_sample(const PcSamplingRecordT* pc_sample,
address_translation::CodeobjAddressTranslate& translator,
address_translation::FlatProfile& flat_profile)
{
// Ignore samples from blit kernels or self-modifying code.
if(pc_sample->correlation_id.internal == ROCPROFILER_CORRELATION_ID_INTERNAL_NONE) return;
auto corr_id = pc_sample->correlation_id;
// Internal correlation IDs are generated by the ROCProfiler-SDK for
// kernel dispatches only. Similarly, the test tool generate external
// correlation IDs for the kernel dispatches only.
// Thus, we should expect them to be equal.
assert(corr_id.internal == corr_id.external.value);
assert(corr_id.external.value > 0);
// Decoding the PC
auto inst = translator.get(pc_sample->pc.code_object_id, pc_sample->pc.code_object_offset);
flat_profile.add_sample(std::move(inst), pc_sample->exec_mask);
// TODO: introduce checks specific to stochastic sampling
// TODO: print an instruction inside print_sample
}
void
rocprofiler_pc_sampling_callback(rocprofiler_context_id_t /*context_id*/,
rocprofiler_buffer_id_t /*buffer_id*/,
@@ -311,7 +422,7 @@ rocprofiler_pc_sampling_callback(rocprofiler_context_id_t /*context_id*/,
{
std::stringstream ss;
ss << "The number of delivered samples is: " << num_headers << ", "
<< "while the number of dropped samples is: " << drop_count << std::endl;
<< "while the number of dropped samples is: " << drop_count << "\n";
auto& flat_profile = client::address_translation::get_flat_profile();
auto& translator = client::address_translation::get_address_translator();
@@ -340,48 +451,26 @@ rocprofiler_pc_sampling_callback(rocprofiler_context_id_t /*context_id*/,
{
auto* pc_sample = static_cast<rocprofiler_pc_sampling_record_host_trap_v0_t*>(
cur_header->payload);
ss << "(code_obj_id, offset): (" << pc_sample->pc.code_object_id << ", 0x"
<< std::hex << pc_sample->pc.code_object_offset << "), "
<< "timestamp: " << std::dec << pc_sample->timestamp << ", "
<< "exec: " << std::hex << std::setw(16) << pc_sample->exec_mask << ", "
<< "workgroup_id_(x=" << std::dec << std::setw(5)
<< pc_sample->workgroup_id.x << ", "
<< "y=" << std::setw(5) << pc_sample->workgroup_id.y << ", "
<< "z=" << std::setw(5) << pc_sample->workgroup_id.z << "), "
<< "wave_in_group: " << std::setw(2)
<< static_cast<unsigned int>(pc_sample->wave_in_group) << ", "
<< "chiplet: " << std::setw(2)
<< static_cast<unsigned int>(pc_sample->hw_id.chiplet) << ", "
<< "dispatch_id: " << std::setw(7) << pc_sample->dispatch_id << ","
<< "correlation: {internal=" << std::setw(7)
<< pc_sample->correlation_id.internal << ", "
<< "external=" << std::setw(5) << pc_sample->correlation_id.external.value
<< "}" << std::endl;
// Ignore samples from blit kernels.
if(pc_sample->correlation_id.internal ==
ROCPROFILER_CORRELATION_ID_INTERNAL_NONE)
continue;
total_samples_num() += 1;
auto corr_id = pc_sample->correlation_id;
// Internal correlation IDs are generated by the ROCProfiler-SDK for
// kernel dispatches only. Similarly, the test tool generate external
// correlation IDs for the kernel dispatches only.
// Thus, we should expect them to be equal.
assert(corr_id.internal == corr_id.external.value);
assert(corr_id.external.value > 0);
// Decoding the PC
auto inst = translator.get(pc_sample->pc.code_object_id,
pc_sample->pc.code_object_offset);
flat_profile.add_sample(std::move(inst), pc_sample->exec_mask);
print_sample(ss, pc_sample);
process_sample(pc_sample, translator, flat_profile);
}
else if(cur_header->kind == ROCPROFILER_PC_SAMPLING_RECORD_STOCHASTIC_V0_SAMPLE)
{
auto* pc_sample = static_cast<rocprofiler_pc_sampling_record_stochastic_v0_t*>(
cur_header->payload);
print_sample(ss, pc_sample);
process_sample(pc_sample, translator, flat_profile);
}
else if(cur_header->kind == ROCPROFILER_PC_SAMPLING_RECORD_INVALID_SAMPLE)
{
// tracking number of invalid samples
flat_profile.add_invalid_sample();
}
else
{
assert(false);
std::cerr << "Unexpected kind of PC sampling record: " << cur_header->kind
<< "\n";
exit(-1);
}
}
else
@@ -391,7 +480,7 @@ rocprofiler_pc_sampling_callback(rocprofiler_context_id_t /*context_id*/,
}
// TODO: do we need some sync here?
*utils::get_output_stream() << ss.str() << std::endl;
*utils::get_output_stream() << ss.str() << "\n";
}
}
} // namespace
@@ -406,12 +495,7 @@ void
fini()
{
delete pc_sampler;
}
std::atomic<uint64_t>&
total_samples_num()
{
return pc_sampler->total_samples_num;
pc_sampler = nullptr;
}
void
@@ -421,9 +505,11 @@ configure_pc_sampling_on_all_agents(rocprofiler_context_id_t context)
if(pc_sampler->gpu_agents.empty())
{
*utils::get_output_stream() << "No availabe gpu agents supporting PC sampling" << std::endl;
*utils::get_output_stream() << "No availabe gpu agents supporting PC sampling"
<< "\n";
// Emit the message to skip the test.
std::cerr << "PC sampling unavailable" << std::endl;
std::cerr << "PC sampling unavailable"
<< "\n";
// Exit with no error if none of the GPUs support PC sampling.
exit(0);
}
@@ -481,7 +567,8 @@ flush_and_destroy_buffers()
if(status == ROCPROFILER_STATUS_ERROR_BUFFER_BUSY)
{
*utils::get_output_stream()
<< "The buffer is busy, so we cannot destroy it at the moment." << std::endl;
<< "The buffer is busy, so we cannot destroy it at the moment."
<< "\n";
}
else
{
tests/pc_sampling/pcs.hpp
-3
View File
@@ -40,9 +40,6 @@ init();
void
fini();
std::atomic<uint64_t>&
total_samples_num();
void
configure_pc_sampling_on_all_agents(rocprofiler_context_id_t context);
tests/pc_sampling/utils.cpp
+14
View File
@@ -33,5 +33,19 @@ get_output_stream()
static std::ostream* _v = nullptr;
return _v;
}
/**
* @brief Shows @p error_msg and aborts if @p condition is false.
*
*/
void
pcs_assert(bool condition, std::string_view error_msg)
{
if(!condition)
{
std::cerr << "PC Sampling Assertion Error: " << error_msg << "\n";
abort();
}
}
} // namespace utils
} // namespace client
tests/pc_sampling/utils.hpp
+4 -1
View File
@@ -61,5 +61,8 @@ namespace utils
{
std::ostream*&
get_output_stream();
}
void
pcs_assert(bool condition, std::string_view error_msg);
} // namespace utils
} // namespace client