From d44815fc0c8426364f3199bdf38da3fe2c5157dc Mon Sep 17 00:00:00 2001 From: Finn Williams Date: Fri, 1 May 2020 13:25:55 +0100 Subject: Update the CounterDirectory Packet offsets to be relative to the start of the table containing that offset * IVGCVSW-4763 Update the event pointer table offsets * IVGCVSW-4764 Update the event record block offsets * IVGCVSW-4765 Update the device name offset * IVGCVSW-4766 Update the counter set name offset * IVGCVSW-4767 Update device pointer table offsets * IVGCVSW-4768 Update the counter set pointer table offsets * IVGCVSW-4769 Update the category pointer table offsets Signed-off-by: Finn Williams Change-Id: I6e815ae5b16478fc5ec760caf704451fe5f84a29 --- src/profiling/test/ProfilingTests.cpp | 6 +- src/profiling/test/SendCounterPacketTests.cpp | 285 ++++++++++++++------------ 2 files changed, 153 insertions(+), 138 deletions(-) (limited to 'src/profiling/test') diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp index bd6ae08e30..dd7d5b8476 100644 --- a/src/profiling/test/ProfilingTests.cpp +++ b/src/profiling/test/ProfilingTests.cpp @@ -2439,13 +2439,13 @@ BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2) BOOST_TEST(bodyHeader1Word5 == 8 + bodyHeaderSizeBytes); // categories_pointer_table_offset const uint32_t deviceRecordOffset = ReadUint32(readBuffer1, 32); - BOOST_TEST(deviceRecordOffset == 0); + BOOST_TEST(deviceRecordOffset == 12); const uint32_t counterSetRecordOffset = ReadUint32(readBuffer1, 36); - BOOST_TEST(counterSetRecordOffset == 20); + BOOST_TEST(counterSetRecordOffset == 28); const uint32_t categoryRecordOffset = ReadUint32(readBuffer1, 40); - BOOST_TEST(categoryRecordOffset == 44); + BOOST_TEST(categoryRecordOffset == 48); auto readBuffer2 = mockBuffer2.GetReadableBuffer(); diff --git a/src/profiling/test/SendCounterPacketTests.cpp b/src/profiling/test/SendCounterPacketTests.cpp index 5bfcd2c14d..dd271c9594 100644 --- a/src/profiling/test/SendCounterPacketTests.cpp +++ b/src/profiling/test/SendCounterPacketTests.cpp @@ -427,7 +427,7 @@ BOOST_AUTO_TEST_CASE(CreateDeviceRecordTest) }; BOOST_CHECK(deviceRecordWord0[0] == deviceUid); // uid BOOST_CHECK(deviceRecordWord0[1] == deviceCores); // cores - BOOST_CHECK(deviceRecord[1] == 0); // name_offset + BOOST_CHECK(deviceRecord[1] == 2); // name_offset BOOST_CHECK(deviceRecord[2] == deviceName.size() + 1); // The length of the SWTrace string (name) BOOST_CHECK(std::memcmp(deviceRecord.data() + 3, deviceName.data(), deviceName.size()) == 0); // name } @@ -480,7 +480,7 @@ BOOST_AUTO_TEST_CASE(CreateCounterSetRecordTest) }; BOOST_CHECK(counterSetRecordWord0[0] == counterSetUid); // uid BOOST_CHECK(counterSetRecordWord0[1] == counterSetCount); // cores - BOOST_CHECK(counterSetRecord[1] == 0); // name_offset + BOOST_CHECK(counterSetRecord[1] == 2); // name_offset BOOST_CHECK(counterSetRecord[2] == counterSetName.size() + 1); // The length of the SWTrace string (name) BOOST_CHECK(std::memcmp(counterSetRecord.data() + 3, counterSetName.data(), counterSetName.size()) == 0); // name } @@ -564,33 +564,39 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordTest) eventRecord[3], eventRecord[4] }; + BOOST_CHECK(eventRecordWord0[0] == maxCounterUid); // max_counter_uid BOOST_CHECK(eventRecordWord0[1] == counterUid); // counter_uid BOOST_CHECK(eventRecordWord1[0] == deviceUid); // device + BOOST_CHECK(eventRecordWord1[1] == counterSetUid); // counter_set BOOST_CHECK(eventRecordWord2[0] == counterClass); // class BOOST_CHECK(eventRecordWord2[1] == counterInterpolation); // interpolation BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier ARMNN_NO_CONVERSION_WARN_BEGIN - uint32_t counterNameOffset = 0; // The name is the first item in pool + uint32_t eventRecordBlockSize = 8u * sizeof(uint32_t); + uint32_t counterNameOffset = eventRecordBlockSize; // The name is the first item in pool uint32_t counterDescriptionOffset = counterNameOffset + // Counter name offset 4u + // Counter name length (uint32_t) counterName.size() + // 18u 1u + // Null-terminator 1u; // Rounding to the next word + size_t counterUnitsOffset = counterDescriptionOffset + // Counter description offset 4u + // Counter description length (uint32_t) counterDescription.size() + // 21u 1u + // Null-terminator - 2u; // Rounding to the next word + 2u; // Rounding to the next word + ARMNN_NO_CONVERSION_WARN_END BOOST_CHECK(eventRecord[5] == counterNameOffset); // name_offset BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset BOOST_CHECK(eventRecord[7] == counterUnitsOffset); // units_offset - auto eventRecordPool = reinterpret_cast(eventRecord.data() + 8u); // The start of the pool + // Offsets are relative to the start of the eventRecord + auto eventRecordPool = reinterpret_cast(eventRecord.data()); size_t uint32_t_size = sizeof(uint32_t); // The length of the SWTrace string (name) @@ -693,7 +699,8 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest) BOOST_CHECK(std::memcmp(eventRecordWord34, &counterMultiplier, sizeof(counterMultiplier)) == 0); // multiplier ARMNN_NO_CONVERSION_WARN_BEGIN - uint32_t counterNameOffset = 0; // The name is the first item in pool + uint32_t eventRecordBlockSize = 8u * sizeof(uint32_t); + uint32_t counterNameOffset = eventRecordBlockSize; // The name is the first item in pool uint32_t counterDescriptionOffset = counterNameOffset + // Counter name offset 4u + // Counter name length (uint32_t) counterName.size() + // 18u @@ -705,7 +712,8 @@ BOOST_AUTO_TEST_CASE(CreateEventRecordNoUnitsTest) BOOST_CHECK(eventRecord[6] == counterDescriptionOffset); // description_offset BOOST_CHECK(eventRecord[7] == 0); // units_offset - auto eventRecordPool = reinterpret_cast(eventRecord.data() + 8u); // The start of the pool + // Offsets are relative to the start of the eventRecord + auto eventRecordPool = reinterpret_cast(eventRecord.data()); size_t uint32_t_size = sizeof(uint32_t); // The length of the SWTrace string (name) @@ -926,15 +934,16 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest) size_t uint32_t_size = sizeof(uint32_t); ARMNN_NO_CONVERSION_WARN_BEGIN - uint32_t eventPointerTableOffset = 0; // The event pointer table is the first item in pool + uint32_t categoryRecordBlockSize = 3u * uint32_t_size; + uint32_t eventPointerTableOffset = categoryRecordBlockSize; // The event pointer table is the first item in pool uint32_t categoryNameOffset = eventPointerTableOffset + // Event pointer table offset categoryEventCount * uint32_t_size; // The size of the event pointer table ARMNN_NO_CONVERSION_WARN_END BOOST_CHECK(categoryRecord[1] == eventPointerTableOffset); // event_pointer_table_offset BOOST_CHECK(categoryRecord[2] == categoryNameOffset); // name_offset - - auto categoryRecordPool = reinterpret_cast(categoryRecord.data() + 3u); // The start of the pool + // Offsets are relative to the start of the category record + auto categoryRecordPool = reinterpret_cast(categoryRecord.data()); // The event pointer table uint32_t eventRecord0Offset = categoryRecordPool[eventPointerTableOffset + 0 * uint32_t_size]; @@ -960,60 +969,71 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest) // Counter1 UID and max counter UID uint16_t eventRecord0Word0[2] = { 0u, 0u }; - std::memcpy(eventRecord0Word0, categoryRecordPool + eventRecord0Offset, sizeof(eventRecord0Word0)); + std::memcpy(eventRecord0Word0, categoryRecordPool + categoryRecordBlockSize + eventRecord0Offset, + sizeof(eventRecord0Word0)); BOOST_CHECK(eventRecord0Word0[0] == counter1->m_Uid); BOOST_CHECK(eventRecord0Word0[1] == counter1->m_MaxCounterUid); // Counter1 name uint32_t counter1NameOffset = 0; - std::memcpy(&counter1NameOffset, categoryRecordPool + eventRecord0Offset + 5u * uint32_t_size, uint32_t_size); + std::memcpy(&counter1NameOffset, categoryRecordPool + eventRecord0Offset + 5u * uint32_t_size, uint32_t_size); BOOST_CHECK(counter1NameOffset == 0); // The length of the SWTrace string (name) - BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool - counter1NameOffset // Offset to the name of the counter + BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record + categoryRecordBlockSize + // Offset to the end of the category record block + 8u * uint32_t_size + // Offset to the event record pool + counter1NameOffset // Offset to the name of the counter ] == counter1->m_Name.size() + 1); // The length of the name including the // null-terminator // The counter1 name - BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool - eventRecord0Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool - counter1NameOffset + // Offset to the name of the counter - uint32_t_size, // The length of the name + BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool + categoryRecordBlockSize + // Offset to the end of the category record block + eventRecord0Offset + // Offset to the event record + 8u * uint32_t_size + // Offset to the event record pool + counter1NameOffset + // Offset to the name of the counter + uint32_t_size, // The length of the name counter1->m_Name.data(), counter1->m_Name.size()) == 0); // name // The null-terminator at the end of the counter1 name - BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool - counter1NameOffset + // Offset to the name of the counter - uint32_t_size + // The length of the name - counter1->m_Name.size() // The name of the counter + BOOST_CHECK(categoryRecordPool[eventRecord0Offset + // Offset to the event record + categoryRecordBlockSize + // Offset to the end of the category record block + 8u * uint32_t_size + // Offset to the event record pool + counter1NameOffset + // Offset to the name of the counter + uint32_t_size + // The length of the name + counter1->m_Name.size() // The name of the counter ] == '\0'); // Counter2 name uint32_t counter2NameOffset = 0; - std::memcpy(&counter2NameOffset, categoryRecordPool + eventRecord1Offset + 5u * uint32_t_size, uint32_t_size); - BOOST_CHECK(counter2NameOffset == 0); + std::memcpy(&counter2NameOffset, categoryRecordPool + + categoryRecordBlockSize + + eventRecord1Offset + + 5u * uint32_t_size, + uint32_t_size); + BOOST_CHECK(counter2NameOffset == 8u * uint32_t_size ); // The length of the SWTrace string (name) + BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool + categoryRecordBlockSize + counter2NameOffset // Offset to the name of the counter ] == counter2->m_Name.size() + 1); // The length of the name including the // null-terminator // The counter2 name - BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool - eventRecord1Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool - counter2NameOffset + // Offset to the name of the counter - uint32_t_size, // The length of the name + BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool + categoryRecordBlockSize + // Offset to the end of the category record block + eventRecord1Offset + // Offset to the event record + counter2NameOffset + // Offset to the name of the counter + uint32_t_size, // The length of the name counter2->m_Name.data(), counter2->m_Name.size()) == 0); // name + + // The null-terminator at the end of the counter2 name - BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record - 8u * uint32_t_size + // Offset to the event record pool - counter2NameOffset + // Offset to the name of the counter - uint32_t_size + // The length of the name - counter2->m_Name.size() // The name of the counter + BOOST_CHECK(categoryRecordPool[eventRecord1Offset + // Offset to the event record + categoryRecordBlockSize + // Offset to the end of the category record block + counter2NameOffset + // Offset to the name of the counter + uint32_t_size + // The length of the name + counter2->m_Name.size() // The name of the counter ] == '\0'); // Counter3 name @@ -1022,12 +1042,14 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest) BOOST_CHECK(counter3NameOffset == 0); // The length of the SWTrace string (name) BOOST_CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record + categoryRecordBlockSize + 8u * uint32_t_size + // Offset to the event record pool counter3NameOffset // Offset to the name of the counter ] == counter3->m_Name.size() + 1); // The length of the name including the // null-terminator // The counter3 name BOOST_CHECK(std::memcmp(categoryRecordPool + // The beginning of the category pool + categoryRecordBlockSize + eventRecord2Offset + // Offset to the event record 8u * uint32_t_size + // Offset to the event record pool counter3NameOffset + // Offset to the name of the counter @@ -1036,6 +1058,7 @@ BOOST_AUTO_TEST_CASE(CreateCategoryRecordTest) counter3->m_Name.size()) == 0); // name // The null-terminator at the end of the counter3 name BOOST_CHECK(categoryRecordPool[eventRecord2Offset + // Offset to the event record + categoryRecordBlockSize + 8u * uint32_t_size + // Offset to the event record pool counter3NameOffset + // Offset to the name of the counter uint32_t_size + // The length of the name @@ -1255,26 +1278,22 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) // Check the device records pointer table const uint32_t deviceRecordOffset0 = ReadUint32(readBuffer, 32); const uint32_t deviceRecordOffset1 = ReadUint32(readBuffer, 36); - BOOST_TEST(deviceRecordOffset0 == 0); // Device record offset for "device1" - BOOST_TEST(deviceRecordOffset1 == 20); // Device record offset for "device2" + BOOST_TEST(deviceRecordOffset0 == 20); // Device record offset for "device1" + BOOST_TEST(deviceRecordOffset1 == 40); // Device record offset for "device2" // Check the counter set pointer table const uint32_t counterSetRecordOffset0 = ReadUint32(readBuffer, 40); - BOOST_TEST(counterSetRecordOffset0 == 40); // Counter set record offset for "counterset1" + BOOST_TEST(counterSetRecordOffset0 == 52); // Counter set record offset for "counterset1" // Check the category pointer table const uint32_t categoryRecordOffset0 = ReadUint32(readBuffer, 44); const uint32_t categoryRecordOffset1 = ReadUint32(readBuffer, 48); - BOOST_TEST(categoryRecordOffset0 == 64); // Category record offset for "category1" - BOOST_TEST(categoryRecordOffset1 == 168); // Category record offset for "category2" + BOOST_TEST(categoryRecordOffset0 == 72); // Category record offset for "category1" + BOOST_TEST(categoryRecordOffset1 == 176); // Category record offset for "category2" // Get the device record pool offset const uint32_t uint32_t_size = sizeof(uint32_t); - const uint32_t packetBodyPoolOffset = 2u * uint32_t_size + // packet_header - bodyHeaderWord1 + // body_header - deviceRecordCount * uint32_t_size + // Size of device_records_pointer_table - counterSetRecordCount * uint32_t_size // Size of counter_set_pointer_table - + categoryRecordCount * uint32_t_size; // Size of categories_pointer_table + const uint32_t packetHeaderSize = 2u * uint32_t_size; // Device record structure/collection used for testing struct DeviceRecord @@ -1286,30 +1305,41 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::string name; }; std::vector deviceRecords; - const uint32_t deviceRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header + const uint32_t deviceRecordsPointerTableOffset = packetHeaderSize + bodyHeaderWord1; // device_records_pointer_table_offset const unsigned char* readData = readBuffer->GetReadableData(); - for (uint32_t i = 0; i < deviceRecordCount; i++) + uint32_t offset = 0; + std::vector data(800); + + for (uint32_t i = 0; i < 800; i+=uint32_t_size) { - // Get the device record offset - const uint32_t deviceRecordOffset = ReadUint32(readBuffer, deviceRecordsPointerTableOffset + i * uint32_t_size); + data[i] = ReadUint32(readBuffer, offset); + offset += uint32_t_size; + } + std::vector deviceRecordOffsets(deviceRecordCount); + offset = deviceRecordsPointerTableOffset; + for (uint32_t i = 0; i < deviceRecordCount; ++i) + { + // deviceRecordOffset is relative to the start of the deviceRecordsPointerTable + deviceRecordOffsets[i] = ReadUint32(readBuffer, offset) + deviceRecordsPointerTableOffset; + offset += uint32_t_size; + } + + for (uint32_t i = 0; i < deviceRecordCount; i++) + { // Collect the data for the device record - const uint32_t deviceRecordWord0 = ReadUint32(readBuffer, - packetBodyPoolOffset + deviceRecordOffset + 0 * uint32_t_size); - const uint32_t deviceRecordWord1 = ReadUint32(readBuffer, - packetBodyPoolOffset + deviceRecordOffset + 1 * uint32_t_size); + const uint32_t deviceRecordWord0 = ReadUint32(readBuffer, deviceRecordOffsets[i] + 0 * uint32_t_size); + const uint32_t deviceRecordWord1 = ReadUint32(readBuffer, deviceRecordOffsets[i] + 1 * uint32_t_size); DeviceRecord deviceRecord; deviceRecord.uid = static_cast(deviceRecordWord0 >> 16); // uid deviceRecord.cores = static_cast(deviceRecordWord0); // cores deviceRecord.name_offset = deviceRecordWord1; // name_offset - uint32_t deviceRecordPoolOffset = packetBodyPoolOffset + // Packet body offset - deviceRecordOffset + // Device record offset - 2 * uint32_t_size + // Device record header - deviceRecord.name_offset; // Device name offset + uint32_t deviceRecordPoolOffset = deviceRecordOffsets[i] + // Packet body offset + deviceRecord.name_offset * uint32_t_size; // Device name offset uint32_t deviceRecordNameLength = ReadUint32(readBuffer, deviceRecordPoolOffset); deviceRecord.name_length = deviceRecordNameLength; // name_length unsigned char deviceRecordNameNullTerminator = // name null-terminator @@ -1334,6 +1364,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) BOOST_CHECK(device->m_Name == deviceRecord.name); } + // Counter set record structure/collection used for testing struct CounterSetRecord { @@ -1346,28 +1377,29 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector counterSetRecords; const uint32_t counterSetRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header bodyHeaderWord3; // counter_set_pointer_table_offset - for (uint32_t i = 0; i < counterSetRecordCount; i++) + + offset = counterSetRecordsPointerTableOffset; + std::vector counterSetRecordOffsets(counterSetRecordCount); + + for (uint32_t i = 0; i < counterSetRecordCount; ++i) { - // Get the counter set record offset - const uint32_t counterSetRecordOffset = ReadUint32(readBuffer, - counterSetRecordsPointerTableOffset + i * uint32_t_size); + // counterSetRecordOffset is relative to the start of the dcounterSetRecordsPointerTable + counterSetRecordOffsets[i] = ReadUint32(readBuffer, offset) + counterSetRecordsPointerTableOffset; + offset += uint32_t_size; + } + for (uint32_t i = 0; i < counterSetRecordCount; i++) + { // Collect the data for the counter set record - const uint32_t counterSetRecordWord0 = ReadUint32(readBuffer, - packetBodyPoolOffset + counterSetRecordOffset + - 0 * uint32_t_size); - const uint32_t counterSetRecordWord1 = ReadUint32(readBuffer, - packetBodyPoolOffset + counterSetRecordOffset + - 1 * uint32_t_size); + const uint32_t counterSetRecordWord0 = ReadUint32(readBuffer, counterSetRecordOffsets[i] + 0 * uint32_t_size); + const uint32_t counterSetRecordWord1 = ReadUint32(readBuffer, counterSetRecordOffsets[i] + 1 * uint32_t_size); CounterSetRecord counterSetRecord; counterSetRecord.uid = static_cast(counterSetRecordWord0 >> 16); // uid counterSetRecord.count = static_cast(counterSetRecordWord0); // count counterSetRecord.name_offset = counterSetRecordWord1; // name_offset - uint32_t counterSetRecordPoolOffset = packetBodyPoolOffset + // Packet body offset - counterSetRecordOffset + // Counter set record offset - 2 * uint32_t_size + // Counter set record header - counterSetRecord.name_offset; // Counter set name offset + uint32_t counterSetRecordPoolOffset = counterSetRecordOffsets[i] + // Packet body offset + counterSetRecord.name_offset * uint32_t_size; // Counter set name offset uint32_t counterSetRecordNameLength = ReadUint32(readBuffer, counterSetRecordPoolOffset); counterSetRecord.name_length = counterSetRecordNameLength; // name_length unsigned char counterSetRecordNameNullTerminator = // name null-terminator @@ -1426,37 +1458,33 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector categoryRecords; const uint32_t categoryRecordsPointerTableOffset = 2u * uint32_t_size + // packet_header bodyHeaderWord5; // categories_pointer_table_offset - for (uint32_t i = 0; i < categoryRecordCount; i++) + + offset = categoryRecordsPointerTableOffset; + std::vector categoryRecordOffsets(categoryRecordCount); + for (uint32_t i = 0; i < categoryRecordCount; ++i) { - // Get the category record offset - const uint32_t categoryRecordOffset = ReadUint32(readBuffer, categoryRecordsPointerTableOffset + - i * uint32_t_size); + // categoryRecordOffset is relative to the start of the categoryRecordsPointerTable + categoryRecordOffsets[i] = ReadUint32(readBuffer, offset) + categoryRecordsPointerTableOffset; + offset += uint32_t_size; + } + for (uint32_t i = 0; i < categoryRecordCount; i++) + { // Collect the data for the category record - const uint32_t categoryRecordWord1 = ReadUint32(readBuffer, - packetBodyPoolOffset + categoryRecordOffset + - 0 * uint32_t_size); - const uint32_t categoryRecordWord2 = ReadUint32(readBuffer, - packetBodyPoolOffset + categoryRecordOffset + - 1 * uint32_t_size); - const uint32_t categoryRecordWord3 = ReadUint32(readBuffer, - packetBodyPoolOffset + categoryRecordOffset + - 2 * uint32_t_size); + const uint32_t categoryRecordWord1 = ReadUint32(readBuffer, categoryRecordOffsets[i] + 0 * uint32_t_size); + const uint32_t categoryRecordWord2 = ReadUint32(readBuffer, categoryRecordOffsets[i] + 1 * uint32_t_size); + const uint32_t categoryRecordWord3 = ReadUint32(readBuffer, categoryRecordOffsets[i] + 2 * uint32_t_size); CategoryRecord categoryRecord; categoryRecord.event_count = static_cast(categoryRecordWord1 >> 16); // event_count categoryRecord.event_pointer_table_offset = categoryRecordWord2; // event_pointer_table_offset categoryRecord.name_offset = categoryRecordWord3; // name_offset - uint32_t categoryRecordPoolOffset = packetBodyPoolOffset + // Packet body offset - categoryRecordOffset + // Category record offset - 3 * uint32_t_size; // Category record header - uint32_t categoryRecordNameLength = ReadUint32(readBuffer, - categoryRecordPoolOffset + categoryRecord.name_offset); + categoryRecordOffsets[i] + categoryRecord.name_offset); categoryRecord.name_length = categoryRecordNameLength; // name_length unsigned char categoryRecordNameNullTerminator = ReadUint8(readBuffer, - categoryRecordPoolOffset + + categoryRecordOffsets[i] + categoryRecord.name_offset + uint32_t_size + categoryRecordNameLength - 1); // name null-terminator @@ -1464,43 +1492,35 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector categoryRecordNameBuffer(categoryRecord.name_length - 1); std::memcpy(categoryRecordNameBuffer.data(), readData + - categoryRecordPoolOffset + + categoryRecordOffsets[i] + categoryRecord.name_offset + uint32_t_size, categoryRecordNameBuffer.size()); categoryRecord.name.assign(categoryRecordNameBuffer.begin(), categoryRecordNameBuffer.end()); // name categoryRecord.event_pointer_table.resize(categoryRecord.event_count); - for (uint32_t eventIndex = 0; eventIndex < categoryRecord.event_count; eventIndex++) + offset = categoryRecordOffsets[i] + categoryRecord.event_pointer_table_offset; + for (uint32_t eventOffsetIndex = 0; eventOffsetIndex < categoryRecord.event_count; ++eventOffsetIndex) { - uint32_t eventRecordOffset = ReadUint32(readBuffer, - categoryRecordPoolOffset + - categoryRecord.event_pointer_table_offset + - eventIndex * uint32_t_size); - categoryRecord.event_pointer_table[eventIndex] = eventRecordOffset; + // eventRecordOffset is relative to the start of the event pointer table + categoryRecord.event_pointer_table[eventOffsetIndex] = ReadUint32(readBuffer, offset) + + categoryRecordOffsets[i] + + categoryRecord.event_pointer_table_offset; + offset += uint32_t_size; + } + for (uint32_t eventIndex = 0; eventIndex < categoryRecord.event_count; eventIndex++) + { + const uint32_t eventOffset = categoryRecord.event_pointer_table[eventIndex]; // Collect the data for the event record - const uint32_t eventRecordWord0 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 0 * uint32_t_size); - const uint32_t eventRecordWord1 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 1 * uint32_t_size); - const uint32_t eventRecordWord2 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 2 * uint32_t_size); - const uint64_t eventRecordWord34 = ReadUint64(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 3 * uint32_t_size); - const uint32_t eventRecordWord5 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 5 * uint32_t_size); - const uint32_t eventRecordWord6 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 6 * uint32_t_size); - const uint32_t eventRecordWord7 = ReadUint32(readBuffer, - categoryRecordPoolOffset + eventRecordOffset + - 7 * uint32_t_size); + const uint32_t eventRecordWord0 = ReadUint32(readBuffer, eventOffset + 0 * uint32_t_size); + const uint32_t eventRecordWord1 = ReadUint32(readBuffer, eventOffset + 1 * uint32_t_size); + const uint32_t eventRecordWord2 = ReadUint32(readBuffer, eventOffset + 2 * uint32_t_size); + const uint64_t eventRecordWord34 = ReadUint64(readBuffer, eventOffset + 3 * uint32_t_size); + const uint32_t eventRecordWord5 = ReadUint32(readBuffer, eventOffset + 5 * uint32_t_size); + const uint32_t eventRecordWord6 = ReadUint32(readBuffer, eventOffset + 6 * uint32_t_size); + const uint32_t eventRecordWord7 = ReadUint32(readBuffer, eventOffset + 7 * uint32_t_size); + EventRecord eventRecord; eventRecord.counter_uid = static_cast(eventRecordWord0); // counter_uid eventRecord.max_counter_uid = static_cast(eventRecordWord0 >> 16); // max_counter_uid @@ -1513,16 +1533,11 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) eventRecord.description_offset = static_cast(eventRecordWord6); // description_offset eventRecord.units_offset = static_cast(eventRecordWord7); // units_offset - uint32_t eventRecordPoolOffset = categoryRecordPoolOffset + // Category record pool offset - eventRecordOffset + // Event record offset - 8 * uint32_t_size; // Event record header - - uint32_t eventRecordNameLength = ReadUint32(readBuffer, - eventRecordPoolOffset + eventRecord.name_offset); + uint32_t eventRecordNameLength = ReadUint32(readBuffer, eventOffset + eventRecord.name_offset); eventRecord.name_length = eventRecordNameLength; // name_length unsigned char eventRecordNameNullTerminator = ReadUint8(readBuffer, - eventRecordPoolOffset + + eventOffset + eventRecord.name_offset + uint32_t_size + eventRecordNameLength - 1); // name null-terminator @@ -1530,18 +1545,18 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector eventRecordNameBuffer(eventRecord.name_length - 1); std::memcpy(eventRecordNameBuffer.data(), readData + - eventRecordPoolOffset + + eventOffset + eventRecord.name_offset + uint32_t_size, eventRecordNameBuffer.size()); eventRecord.name.assign(eventRecordNameBuffer.begin(), eventRecordNameBuffer.end()); // name uint32_t eventRecordDescriptionLength = ReadUint32(readBuffer, - eventRecordPoolOffset + eventRecord.description_offset); + eventOffset + eventRecord.description_offset); eventRecord.description_length = eventRecordDescriptionLength; // description_length unsigned char eventRecordDescriptionNullTerminator = ReadUint8(readBuffer, - eventRecordPoolOffset + + eventOffset + eventRecord.description_offset + uint32_t_size + eventRecordDescriptionLength - 1); // description null-terminator @@ -1549,7 +1564,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector eventRecordDescriptionBuffer(eventRecord.description_length - 1); std::memcpy(eventRecordDescriptionBuffer.data(), readData + - eventRecordPoolOffset + + eventOffset + eventRecord.description_offset + uint32_t_size, eventRecordDescriptionBuffer.size()); @@ -1559,11 +1574,11 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) if (eventRecord.units_offset > 0) { uint32_t eventRecordUnitsLength = ReadUint32(readBuffer, - eventRecordPoolOffset + eventRecord.units_offset); + eventOffset + eventRecord.units_offset); eventRecord.units_length = eventRecordUnitsLength; // units_length unsigned char eventRecordUnitsNullTerminator = ReadUint8(readBuffer, - eventRecordPoolOffset + + eventOffset + eventRecord.units_offset + uint32_t_size + eventRecordUnitsLength - 1); // units null-terminator @@ -1571,7 +1586,7 @@ BOOST_AUTO_TEST_CASE(SendCounterDirectoryPacketTest2) std::vector eventRecordUnitsBuffer(eventRecord.units_length - 1); std::memcpy(eventRecordUnitsBuffer.data(), readData + - eventRecordPoolOffset + + eventOffset + eventRecord.units_offset + uint32_t_size, eventRecordUnitsBuffer.size()); -- cgit v1.2.1