AI/rocm-systems
2
0
Rozštěpit 0
Zdrojový kód Úkoly Pull requesty Akce Balíčky Projekty Vydání Wiki Aktivita

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

Procházet zdrojové kódy 
* 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>
Tento commit je obsažen v:
Indic, Vladimir
2025-03-21 20:40:45 +01:00
odevzdal GitHub
rodič c06feccf2a
revize 49ce79a5b5
98 změnil soubory, kde provedl 5266 přidání a 1031 odebrání
Stáhněte soubor záplaty Stáhněte rozdílový soubor Rozbalit všechny soubory Sbalit všechny soubory
source/lib/rocprofiler-sdk/pc_sampling/parser/tests/gfx9test.cpp
+311 -232
Zobrazit soubor
@@ -30,75 +30,113 @@
#include <rocprofiler-sdk/cxx/operators.hpp>
#include <gtest/gtest.h>
#include <cassert>
#include <cstddef>
#define GFXIP_MAJOR 9
#define TYPECHECK(x) \
snapshots.push_back(rocprofiler_pc_sampling_snapshot_v1_t{.dual_issue_valu = 0, \
.inst_type = ::PCSAMPLE::x, \
.reason_not_issued = 0, \
.arb_state_issue = 0, \
.arb_state_stall = 0});
#define UNROLL_TYPECHECK() \
TYPECHECK(TYPE_VALU); \
TYPECHECK(TYPE_MATRIX); \
TYPECHECK(TYPE_SCALAR); \
TYPECHECK(TYPE_TEX); \
TYPECHECK(TYPE_LDS); \
TYPECHECK(TYPE_FLAT); \
TYPECHECK(TYPE_EXP); \
TYPECHECK(TYPE_MESSAGE); \
TYPECHECK(TYPE_BARRIER); \
TYPECHECK(TYPE_BRANCH_NOT_TAKEN); \
TYPECHECK(TYPE_BRANCH_TAKEN); \
TYPECHECK(TYPE_JUMP); \
TYPECHECK(TYPE_OTHER); \
TYPECHECK(TYPE_NO_INST);
#define RECORD_INST_TYPE(x) \
{ \
PcSamplingRecordT sample{}; \
sample.inst_type = ROCPROFILER_PC_SAMPLING_INSTRUCTION##_##x; \
snapshots.push_back(sample); \
}
#define REASONCHECK(x) \
snapshots.push_back(rocprofiler_pc_sampling_snapshot_v1_t{.dual_issue_valu = 0, \
.inst_type = 0, \
.reason_not_issued = ::PCSAMPLE::x, \
.arb_state_issue = 0, \
.arb_state_stall = 0});
#define UNROLL_REASONCHECK(x) \
REASONCHECK(REASON_NOT_AVAILABLE); \
REASONCHECK(REASON_ALU); \
REASONCHECK(REASON_WAITCNT); \
REASONCHECK(REASON_INTERNAL); \
REASONCHECK(REASON_BARRIER); \
REASONCHECK(REASON_ARBITER); \
REASONCHECK(REASON_EX_STALL); \
REASONCHECK(REASON_OTHER_WAIT);
#define GENERATE_RECORDS_INST_TYPE() \
RECORD_INST_TYPE(TYPE_VALU); \
RECORD_INST_TYPE(TYPE_MATRIX); \
RECORD_INST_TYPE(TYPE_SCALAR); \
RECORD_INST_TYPE(TYPE_TEX); \
RECORD_INST_TYPE(TYPE_LDS); \
RECORD_INST_TYPE(TYPE_FLAT); \
RECORD_INST_TYPE(TYPE_EXPORT); \
RECORD_INST_TYPE(TYPE_MESSAGE); \
RECORD_INST_TYPE(TYPE_BARRIER); \
RECORD_INST_TYPE(TYPE_BRANCH_NOT_TAKEN); \
RECORD_INST_TYPE(TYPE_BRANCH_TAKEN); \
RECORD_INST_TYPE(TYPE_JUMP); \
RECORD_INST_TYPE(TYPE_OTHER); \
RECORD_INST_TYPE(TYPE_NO_INST);
#define ARBCHECK1(x, y) \
snapshots.push_back( \
rocprofiler_pc_sampling_snapshot_v1_t{.dual_issue_valu = 0, \
.inst_type = 0, \
.reason_not_issued = 0, \
.arb_state_issue = 1 << ::PCSAMPLE::x, \
.arb_state_stall = 1 << ::PCSAMPLE::y});
#define ARBCHECK2(x) \
ARBCHECK1(x, ISSUE_VALU); \
ARBCHECK1(x, ISSUE_MATRIX); \
ARBCHECK1(x, ISSUE_SCALAR); \
ARBCHECK1(x, ISSUE_VMEM_TEX); \
ARBCHECK1(x, ISSUE_LDS); \
ARBCHECK1(x, ISSUE_FLAT); \
ARBCHECK1(x, ISSUE_EXP); \
ARBCHECK1(x, ISSUE_MISC);
#define RECORD_NOT_ISSUED_REASON(x) \
{ \
PcSamplingRecordT sample{}; \
sample.snapshot.reason_not_issued = ROCPROFILER_PC_SAMPLING_INSTRUCTION_NOT_ISSUED##_##x; \
snapshots.push_back(sample); \
}
#define UNROLL_ARBCHECK() \
ARBCHECK2(ISSUE_VALU); \
ARBCHECK2(ISSUE_MATRIX); \
ARBCHECK2(ISSUE_SCALAR); \
ARBCHECK2(ISSUE_VMEM_TEX); \
ARBCHECK2(ISSUE_LDS); \
ARBCHECK2(ISSUE_FLAT); \
ARBCHECK2(ISSUE_EXP); \
ARBCHECK2(ISSUE_MISC);
#define GENERATE_RECORDS_NOT_ISSUED_REASON(x) \
RECORD_NOT_ISSUED_REASON(REASON_NO_INSTRUCTION_AVAILABLE); \
RECORD_NOT_ISSUED_REASON(REASON_ALU_DEPENDENCY); \
RECORD_NOT_ISSUED_REASON(REASON_WAITCNT); \
RECORD_NOT_ISSUED_REASON(REASON_INTERNAL_INSTRUCTION); \
RECORD_NOT_ISSUED_REASON(REASON_BARRIER_WAIT); \
RECORD_NOT_ISSUED_REASON(REASON_ARBITER_NOT_WIN); \
RECORD_NOT_ISSUED_REASON(REASON_ARBITER_WIN_EX_STALL); \
RECORD_NOT_ISSUED_REASON(REASON_OTHER_WAIT);
#define RECORD_ARBSTATE_ISSUE_STALL(x, y) \
{ \
PcSamplingRecordT sample{}; \
sample.snapshot.arb_state##_##x = 1; \
sample.snapshot.arb_state##_##y = 1; \
snapshots.push_back(sample); \
}
// Respecting the order of elements in GFX9:arb_state that match the order of arb_state bits
// in perf_snapshot_data register
#define RECORD_ARBSTATE_ISSUE(x) \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_misc); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_exp); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_flat); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_lds); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_vmem_tex); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_scalar); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_matrix); \
RECORD_ARBSTATE_ISSUE_STALL(x, stall_valu);
// Respecting the order of elements in GFX9:arb_state that match the order of arb_state bits
// in perf_snapshot_data register
#define GENERATE_RECORDS_ARBSTATE_ISSUE() \
RECORD_ARBSTATE_ISSUE(issue_misc); \
RECORD_ARBSTATE_ISSUE(issue_exp); \
RECORD_ARBSTATE_ISSUE(issue_flat); \
RECORD_ARBSTATE_ISSUE(issue_lds); \
RECORD_ARBSTATE_ISSUE(issue_vmem_tex); \
RECORD_ARBSTATE_ISSUE(issue_scalar); \
RECORD_ARBSTATE_ISSUE(issue_matrix); \
RECORD_ARBSTATE_ISSUE(issue_valu);
#define NON_GFX9_ARBSTATE_IS_ZERO(x, y) \
EXPECT_EQ(x.snapshot.arb_state_issue_lds_direct, 0); \
EXPECT_EQ(y.snapshot.arb_state_issue_lds_direct, 0); \
EXPECT_EQ(x.snapshot.arb_state_issue_brmsg, 0); \
EXPECT_EQ(y.snapshot.arb_state_issue_brmsg, 0); \
\
EXPECT_EQ(x.snapshot.arb_state_stall_lds_direct, 0); \
EXPECT_EQ(y.snapshot.arb_state_stall_lds_direct, 0); \
EXPECT_EQ(x.snapshot.arb_state_stall_brmsg, 0); \
EXPECT_EQ(y.snapshot.arb_state_stall_brmsg, 0);
#define MATCH_ARBSTATE(x, y) \
EXPECT_EQ(x.snapshot.arb_state_issue_valu, y.snapshot.arb_state_issue_valu); \
EXPECT_EQ(x.snapshot.arb_state_issue_matrix, y.snapshot.arb_state_issue_matrix); \
EXPECT_EQ(x.snapshot.arb_state_issue_lds, y.snapshot.arb_state_issue_lds); \
EXPECT_EQ(x.snapshot.arb_state_issue_scalar, y.snapshot.arb_state_issue_scalar); \
EXPECT_EQ(x.snapshot.arb_state_issue_vmem_tex, y.snapshot.arb_state_issue_vmem_tex); \
EXPECT_EQ(x.snapshot.arb_state_issue_flat, y.snapshot.arb_state_issue_flat); \
EXPECT_EQ(x.snapshot.arb_state_issue_exp, y.snapshot.arb_state_issue_exp); \
EXPECT_EQ(x.snapshot.arb_state_issue_misc, y.snapshot.arb_state_issue_misc); \
\
EXPECT_EQ(x.snapshot.arb_state_stall_valu, y.snapshot.arb_state_stall_valu); \
EXPECT_EQ(x.snapshot.arb_state_stall_matrix, y.snapshot.arb_state_stall_matrix); \
EXPECT_EQ(x.snapshot.arb_state_stall_lds, y.snapshot.arb_state_stall_lds); \
EXPECT_EQ(x.snapshot.arb_state_stall_scalar, y.snapshot.arb_state_stall_scalar); \
EXPECT_EQ(x.snapshot.arb_state_stall_vmem_tex, y.snapshot.arb_state_stall_vmem_tex); \
EXPECT_EQ(x.snapshot.arb_state_stall_flat, y.snapshot.arb_state_stall_flat); \
EXPECT_EQ(x.snapshot.arb_state_stall_exp, y.snapshot.arb_state_stall_exp); \
EXPECT_EQ(x.snapshot.arb_state_stall_misc, y.snapshot.arb_state_stall_misc); \
\
NON_GFX9_ARBSTATE_IS_ZERO(x, y)
template <typename PcSamplingRecordT>
class WaveSnapTest
@@ -134,10 +172,11 @@ public:
snap.correlation_id = dispatch->getMockId().raw;
snap.perf_snapshot_data = (inst_type << 3) | (reason << 7);
snap.perf_snapshot_data |= 0x1; // sample is valid
snap.perf_snapshot_data |= (arb_issue << 10) | (arb_stall << 18);
snap.perf_snapshot_data1 = wave_cnt;
assert(dispatch.get());
EXPECT_NE(dispatch.get(), nullptr);
dispatch->submit(packet_union_t{.snap = snap});
};
@@ -156,180 +195,213 @@ public:
this->buffer->genUpcomingSamples(max_wave_number);
for(size_t i = 0; i < max_wave_number; i++)
this->genPCSample(
i, GFX9::TYPE_LDS, GFX9::REASON_ALU, GFX9::ISSUE_VALU, GFX9::ISSUE_VALU);
i, GFX9::TYPE_LDS, GFX9::REASON_ALU_DEPENDENCY, GFX9::ISSUE_VALU, GFX9::ISSUE_VALU);
}
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
assert(parsed.size() == 1);
assert(parsed[0].size() == max_wave_number);
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), max_wave_number);
for(size_t i = 0; i < max_wave_number; i++)
assert(parsed[0][i].wave_count == i);
EXPECT_EQ(parsed[0][i].wave_count, i);
}
const size_t max_wave_number = 64;
std::vector<PcSamplingRecordT> snapshots;
};
// class InstTypeTest : public WaveSnapTest
// {
// public:
// void FillBuffers() override
// {
// // Loop over inst_type_issued
// UNROLL_TYPECHECK();
// buffer->genUpcomingSamples(GFX9::TYPE_LAST);
// for(int i = 0; i < GFX9::TYPE_LAST; i++)
// genPCSample(i, i, GFX9::REASON_ALU, GFX9::ISSUE_MATRIX, GFX9::ISSUE_MATRIX);
// }
template <typename PcSamplingRecordT>
class InstTypeTest : public WaveSnapTest<PcSamplingRecordT>
{
public:
void FillBuffers() override
{
// Loop over inst_type_issued
GENERATE_RECORDS_INST_TYPE();
this->buffer->genUpcomingSamples(GFX9::TYPE_LAST);
for(int i = 0; i < GFX9::TYPE_LAST; i++)
this->genPCSample(
i, i, GFX9::REASON_ALU_DEPENDENCY, GFX9::ISSUE_MATRIX, GFX9::ISSUE_MATRIX);
}
// void CheckBuffers() override
// {
// auto parsed = buffer->get_parsed_buffer(9); // GFXIP==9
// assert(parsed.size() == 1);
// assert(parsed[0].size() == GFX9::TYPE_LAST);
// assert(snapshots.size() == GFX9::TYPE_LAST);
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), GFX9::TYPE_LAST);
EXPECT_EQ(snapshots.size(), GFX9::TYPE_LAST);
// for(size_t i = 0; i < GFX9::TYPE_LAST; i++)
// assert(snapshots[i].inst_type == parsed[0][i].snapshot.inst_type);
// }
for(size_t i = 0; i < GFX9::TYPE_LAST; i++)
EXPECT_EQ(snapshots[i].inst_type, parsed[0][i].inst_type);
}
// std::vector<rocprofiler_pc_sampling_snapshot_v1_t> snapshots;
// };
std::vector<PcSamplingRecordT> snapshots;
};
// class StallReasonTest : public WaveSnapTest
// {
// public:
// void FillBuffers() override
// {
// // Loop over reason_not_issued
// UNROLL_REASONCHECK();
// buffer->genUpcomingSamples(GFX9::REASON_LAST);
// for(int i = 0; i < GFX9::REASON_LAST; i++)
// genPCSample(i, GFX9::TYPE_MATRIX, i, GFX9::ISSUE_MATRIX, GFX9::ISSUE_MATRIX);
// }
template <typename PcSamplingRecordT>
class StallReasonTest : public WaveSnapTest<PcSamplingRecordT>
{
public:
void FillBuffers() override
{
// Loop over reason_not_issued
GENERATE_RECORDS_NOT_ISSUED_REASON();
this->buffer->genUpcomingSamples(GFX9::REASON_LAST);
for(int i = 0; i < GFX9::REASON_LAST; i++)
this->genPCSample(i, GFX9::TYPE_MATRIX, i, GFX9::ISSUE_MATRIX, GFX9::ISSUE_MATRIX);
}
// void CheckBuffers() override
// {
// auto parsed = buffer->get_parsed_buffer(9); // GFXIP==9
// assert(parsed.size() == 1);
// assert(parsed[0].size() == GFX9::REASON_LAST);
// assert(snapshots.size() == GFX9::REASON_LAST);
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), GFX9::REASON_LAST);
EXPECT_EQ(snapshots.size(), GFX9::REASON_LAST);
// for(size_t i = 0; i < GFX9::REASON_LAST; i++)
// assert(snapshots[i].reason_not_issued == parsed[0][i].snapshot.reason_not_issued);
// }
for(size_t i = 0; i < GFX9::REASON_LAST; i++)
EXPECT_EQ(snapshots[i].snapshot.reason_not_issued,
parsed[0][i].snapshot.reason_not_issued);
}
// std::vector<rocprofiler_pc_sampling_snapshot_v1_t> snapshots;
// };
std::vector<PcSamplingRecordT> snapshots;
};
// class ArbStateTest : public WaveSnapTest
// {
// public:
// void FillBuffers() override
// {
// // Loop over arb_state_issue
// UNROLL_ARBCHECK();
// buffer->genUpcomingSamples(GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
// for(int i = 0; i < GFX9::ISSUE_LAST; i++)
// for(int j = 0; j < GFX9::ISSUE_LAST; j++)
// genPCSample(i, GFX9::TYPE_MATRIX, GFX9::REASON_ALU, 1 << i, 1 << j);
// }
template <typename PcSamplingRecordT>
class ArbStateTest : public WaveSnapTest<PcSamplingRecordT>
{
public:
void FillBuffers() override
{
// Loop over arb_state_issue
GENERATE_RECORDS_ARBSTATE_ISSUE();
this->buffer->genUpcomingSamples(GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
// To match the order of instantiating snapshots inside `GENERATE_RECORDS_ARBSTATE_ISSUE`
// we loop over GFX9::
for(int i = 0; i < GFX9::ISSUE_LAST; i++)
for(int j = 0; j < GFX9::ISSUE_LAST; j++)
this->genPCSample(
i, GFX9::TYPE_MATRIX, GFX9::REASON_ALU_DEPENDENCY, 1 << i, 1 << j);
}
// void CheckBuffers() override
// {
// auto parsed = buffer->get_parsed_buffer(9); // GFXIP==9
// assert(parsed.size() == 1);
// assert(parsed[0].size() == GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
// assert(snapshots.size() == GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
EXPECT_EQ(snapshots.size(), GFX9::ISSUE_LAST * GFX9::ISSUE_LAST);
// for(size_t i = 0; i < GFX9::ISSUE_LAST * GFX9::ISSUE_LAST; i++)
// {
// auto& snap = snapshots[i];
// assert(snap.arb_state_issue == parsed[0][i].snapshot.arb_state_issue);
// assert(snap.arb_state_stall == parsed[0][i].snapshot.arb_state_stall);
// }
// }
for(size_t i = 0; i < GFX9::ISSUE_LAST * GFX9::ISSUE_LAST; i++)
{
auto& snap = snapshots[i];
MATCH_ARBSTATE(snap, parsed[0][i])
}
}
// std::vector<rocprofiler_pc_sampling_snapshot_v1_t> snapshots;
// };
std::vector<PcSamplingRecordT> snapshots;
};
// class WaveIssueAndErrorTest : public WaveSnapTest
// {
// void FillBuffers() override
// {
// buffer->genUpcomingSamples(16);
// for(int valid = 0; valid <= 1; valid++)
// for(int issued = 0; issued <= 1; issued++)
// for(int dual = 0; dual <= 1; dual++)
// for(int error = 0; error <= 1; error++)
// genPCSample(valid, issued, dual, error);
// }
template <typename PcSamplingRecordT, typename PcSamplingRecordInvalidT>
class WaveIssueAndErrorTest : public WaveSnapTest<PcSamplingRecordT>
{
struct pc_sampling_test_record_t
{
bool valid;
union
{
PcSamplingRecordT valid_record;
PcSamplingRecordInvalidT invalid_record;
};
};
// void CheckBuffers() override
// {
// const int num_combinations = 16;
// auto parsed = buffer->get_parsed_buffer(9); // GFXIP==9
// assert(parsed.size() == 1);
// assert(parsed[0].size() == num_combinations);
// assert(compare.size() == num_combinations);
void FillBuffers() override
{
this->buffer->genUpcomingSamples(16);
for(int valid = 0; valid <= 1; valid++)
for(int issued = 0; issued <= 1; issued++)
for(int dual = 0; dual <= 1; dual++)
for(int error = 0; error <= 1; error++)
genPCSample(valid, issued, dual, error);
}
// for(size_t i = 0; i < num_combinations; i++)
// {
// assert(compare[i].flags.valid == parsed[0][i].flags.valid);
// assert(compare[i].wave_issued == parsed[0][i].wave_issued);
// assert(compare[i].snapshot.dual_issue_valu == parsed[0][i].snapshot.dual_issue_valu);
// }
// }
void CheckBuffers() override
{
const int num_combinations = 16;
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), num_combinations);
EXPECT_EQ(compare.size(), num_combinations);
// union trap_snapshot_v1
// {
// struct
// {
// uint32_t valid : 1;
// uint32_t issued : 1;
// uint32_t dual : 1;
// uint32_t reserved : 23;
// uint32_t error : 1;
// uint32_t reserved2 : 5;
// };
// uint32_t raw;
// };
for(size_t i = 0; i < num_combinations; i++)
{
if(compare[i].valid)
{
EXPECT_EQ(compare[i].valid_record.wave_issued, parsed[0][i].wave_issued);
EXPECT_EQ(compare[i].valid_record.snapshot.dual_issue_valu,
parsed[0][i].snapshot.dual_issue_valu);
}
else
{
// Internally (inside the parser) invalid samples are represented with
// PcSamplingRecordT of size 0. Eventually, those records are replaced with the
// PcSamplingRecordInvalidT prior to putting inside the SDK buffer.
EXPECT_EQ(parsed[0][i].size, 0);
}
}
}
// void genPCSample(bool valid, bool issued, bool dual, bool error)
// {
// rocprofiler_pc_sampling_record_t sample;
// ::memset(&sample, 0, sizeof(sample));
// // TODO: Since code objects are not mocked, use pc.code_object_offset
// // as the absolute physical address of the mocked PC.
// sample.pc.code_object_offset = dispatch->unique_id;
union trap_snapshot_v1
{
struct
{
uint32_t valid : 1;
uint32_t issued : 1;
uint32_t dual : 1;
uint32_t reserved : 23;
uint32_t error : 1;
uint32_t reserved2 : 5;
};
uint32_t raw;
};
// sample.correlation_id.internal = dispatch->getMockId().raw;
void genPCSample(bool valid, bool issued, bool dual, bool error)
{
pc_sampling_test_record_t record{};
record.valid = valid && !error;
if(record.valid)
{
// Fill in the data for the valid record.
auto& sample = record.valid_record;
// sample.flags.valid = valid && !error;
// sample.wave_issued = issued;
// sample.snapshot.dual_issue_valu = dual;
// TODO: Since code objects are not mocked, use pc.code_object_offset
// as the absolute physical address of the mocked PC.
sample.pc.code_object_offset = this->dispatch->unique_id;
// assert(dispatch.get());
sample.correlation_id.internal = this->dispatch->getMockId().raw;
// compare.push_back(sample);
sample.wave_issued = issued;
sample.snapshot.dual_issue_valu = dual;
// trap_snapshot_v1 snap;
// snap.valid = valid;
// snap.issued = issued;
// snap.dual = dual;
// snap.error = error;
EXPECT_NE(this->dispatch.get(), nullptr);
}
// perf_sample_snapshot_v1 pss;
// pss.perf_snapshot_data = snap.raw;
// pss.correlation_id = dispatch->getMockId().raw;
// dispatch->submit(std::move(pss));
// };
compare.push_back(record);
// std::vector<rocprofiler_pc_sampling_record_t> compare;
// };
trap_snapshot_v1 snap;
snap.valid = valid;
snap.issued = issued;
snap.dual = dual;
snap.error = error;
perf_sample_snapshot_v1 pss;
pss.perf_snapshot_data = snap.raw;
pss.correlation_id = this->dispatch->getMockId().raw;
this->dispatch->submit(std::move(pss));
};
std::vector<pc_sampling_test_record_t> compare;
};
template <typename PcSamplingRecordT>
class HwIdTest : public WaveSnapTest<PcSamplingRecordT>
@@ -405,23 +477,23 @@ class HwIdTest : public WaveSnapTest<PcSamplingRecordT>
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
assert(parsed.size() == 1);
assert(parsed[0].size() == 3);
assert(compare.size() == 3);
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), 3);
EXPECT_EQ(compare.size(), 3);
for(size_t i = 0; i < 3; i++)
{
// Comparing individual fields
assert(compare[i].hw_id.wave_id == parsed[0][i].hw_id.wave_id);
assert(compare[i].hw_id.simd_id == parsed[0][i].hw_id.simd_id);
assert(compare[i].hw_id.pipe_id == parsed[0][i].hw_id.pipe_id);
assert(compare[i].hw_id.cu_or_wgp_id == parsed[0][i].hw_id.cu_or_wgp_id);
assert(compare[i].hw_id.shader_array_id == parsed[0][i].hw_id.shader_array_id);
assert(compare[i].hw_id.shader_engine_id == parsed[0][i].hw_id.shader_engine_id);
assert(compare[i].hw_id.workgroup_id == parsed[0][i].hw_id.workgroup_id);
assert(compare[i].hw_id.vm_id == parsed[0][i].hw_id.vm_id);
assert(compare[i].hw_id.queue_id == parsed[0][i].hw_id.queue_id);
assert(compare[i].hw_id.microengine_id == parsed[0][i].hw_id.microengine_id);
EXPECT_EQ(compare[i].hw_id.wave_id, parsed[0][i].hw_id.wave_id);
EXPECT_EQ(compare[i].hw_id.simd_id, parsed[0][i].hw_id.simd_id);
EXPECT_EQ(compare[i].hw_id.pipe_id, parsed[0][i].hw_id.pipe_id);
EXPECT_EQ(compare[i].hw_id.cu_or_wgp_id, parsed[0][i].hw_id.cu_or_wgp_id);
EXPECT_EQ(compare[i].hw_id.shader_array_id, parsed[0][i].hw_id.shader_array_id);
EXPECT_EQ(compare[i].hw_id.shader_engine_id, parsed[0][i].hw_id.shader_engine_id);
EXPECT_EQ(compare[i].hw_id.workgroup_id, parsed[0][i].hw_id.workgroup_id);
EXPECT_EQ(compare[i].hw_id.vm_id, parsed[0][i].hw_id.vm_id);
EXPECT_EQ(compare[i].hw_id.queue_id, parsed[0][i].hw_id.queue_id);
EXPECT_EQ(compare[i].hw_id.microengine_id, parsed[0][i].hw_id.microengine_id);
}
}
@@ -451,8 +523,9 @@ class HwIdTest : public WaveSnapTest<PcSamplingRecordT>
// raw register value
snap.hw_id = hw_id.raw;
snap.correlation_id = this->dispatch->getMockId().raw;
snap.perf_snapshot_data |= 0x1; // sample is valid
assert(this->dispatch.get());
EXPECT_NE(this->dispatch.get(), nullptr);
this->dispatch->submit(snap);
};
@@ -473,26 +546,26 @@ class WaveOtherFieldsTest : public WaveSnapTest<PcSamplingRecordT>
void CheckBuffers() override
{
auto parsed = this->buffer->get_parsed_buffer(9); // GFXIP==9
assert(parsed.size() == 1);
assert(parsed[0].size() == 3);
assert(compare.size() == 3);
EXPECT_EQ(parsed.size(), 1);
EXPECT_EQ(parsed[0].size(), 3);
EXPECT_EQ(compare.size(), 3);
for(size_t i = 0; i < 3; i++)
{
// TODO: if we decide to test flags, make specialization for
// rocprofiler_pc_sampling_record_stochastic_v0_t
// assert(parsed[0][i].flags.has_stall_reason == true);
// assert(parsed[0][i].flags.has_wave_cnt == true);
// assert(parsed[0][i].flags.reserved == false);
// EXPECT_EQ(parsed[0][i].flags.has_stall_reason, true);
// EXPECT_EQ(parsed[0][i].flags.has_wave_cnt, true);
// EXPECT_EQ(parsed[0][i].flags.reserved, false);
assert(compare[i].exec_mask == parsed[0][i].exec_mask);
assert(compare[i].workgroup_id == parsed[0][i].workgroup_id);
EXPECT_EQ(compare[i].exec_mask, parsed[0][i].exec_mask);
EXPECT_EQ(compare[i].workgroup_id, parsed[0][i].workgroup_id);
assert(compare[i].hw_id.chiplet == parsed[0][i].hw_id.chiplet);
assert(compare[i].wave_in_group == parsed[0][i].wave_in_group);
EXPECT_EQ(compare[i].hw_id.chiplet, parsed[0][i].hw_id.chiplet);
EXPECT_EQ(compare[i].wave_in_group, parsed[0][i].wave_in_group);
// TODO: handle HW_ID as well.
// assert(compare[i].hw_id == parsed[0][i].hw_id);
assert(compare[i].correlation_id.internal == parsed[0][i].correlation_id.internal);
// EXPECT_EQ(compare[i].hw_id, parsed[0][i].hw_id);
EXPECT_EQ(compare[i].correlation_id.internal, parsed[0][i].correlation_id.internal);
}
}
@@ -525,7 +598,11 @@ class WaveOtherFieldsTest : public WaveSnapTest<PcSamplingRecordT>
snap.chiplet_and_wave_id = (chip << 8) | (wave & 0x3F);
snap.correlation_id = this->dispatch->getMockId().raw;
assert(this->dispatch.get());
// to ensure all stochastic samples are generated properly,
// marked them as valid
snap.perf_snapshot_data |= 0x1; // set the bit indicating the sample is valid
EXPECT_NE(this->dispatch.get(), nullptr);
this->dispatch->submit(snap);
(void) pc;
@@ -538,10 +615,12 @@ TEST(pcs_parser, gfx9_test)
{
// Tests specific to stochastic sampling only
WaveCntTest<rocprofiler_pc_sampling_record_stochastic_v0_t>{}.Test();
// InstTypeTest{}.Test();
// StallReasonTest{}.Test();
// ArbStateTest{}.Test();
// WaveIssueAndErrorTest{}.Test();
InstTypeTest<rocprofiler_pc_sampling_record_stochastic_v0_t>{}.Test();
StallReasonTest<rocprofiler_pc_sampling_record_stochastic_v0_t>{}.Test();
ArbStateTest<rocprofiler_pc_sampling_record_stochastic_v0_t>{}.Test();
WaveIssueAndErrorTest<rocprofiler_pc_sampling_record_stochastic_v0_t,
rocprofiler_pc_sampling_record_invalid_t>{}
.Test();
// Tests commong for both host trap and stochastic sampling.
HwIdTest<rocprofiler_pc_sampling_record_host_trap_v0_t>{}.Test();