#include <algorithm>
#include <string>
#include <vector>
+#include <thread>
namespace armnn
{
virtual void SendTimelineEntityBinaryPacket(uint64_t profilingGuid) = 0;
/// Create and write a TimelineEventBinaryPacket from the parameters to the buffer.
- virtual void SendTimelineEventBinaryPacket(uint64_t timestamp, uint32_t threadId, uint64_t profilingGuid) = 0;
+ virtual void SendTimelineEventBinaryPacket(uint64_t timestamp,
+ std::thread::id threadId,
+ uint64_t profilingGuid) = 0;
/// Create and write a TimelineEventClassBinaryPacket from the parameters to the buffer.
virtual void SendTimelineEventClassBinaryPacket(uint64_t profilingGuid) = 0;
return counterUids;
}
+void WriteBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize)
+{
+ BOOST_ASSERT(packetBuffer);
+
+ WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
+}
+
void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value)
{
BOOST_ASSERT(packetBuffer);
WriteUint16(packetBuffer->GetWritableData(), offset, value);
}
+void WriteBytes(unsigned char* buffer, unsigned int offset, const void* value, unsigned int valueSize)
+{
+ BOOST_ASSERT(buffer);
+ BOOST_ASSERT(value);
+
+ for (unsigned int i = 0; i < valueSize; i++, offset++)
+ {
+ buffer[offset] = *(reinterpret_cast<const unsigned char*>(value) + i);
+ }
+}
+
void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value)
{
BOOST_ASSERT(buffer);
buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
}
+void ReadBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
+{
+ BOOST_ASSERT(packetBuffer);
+
+ ReadBytes(packetBuffer->GetReadableData(), offset, valueSize, outValue);
+}
+
uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset)
{
BOOST_ASSERT(packetBuffer);
return ReadUint8(packetBuffer->GetReadableData(), offset);
}
+void ReadBytes(const unsigned char* buffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[])
+{
+ BOOST_ASSERT(buffer);
+ BOOST_ASSERT(outValue);
+
+ for (unsigned int i = 0; i < valueSize; i++, offset++)
+ {
+ outValue[i] = static_cast<uint8_t>(buffer[offset]);
+ }
+}
+
uint64_t ReadUint64(const unsigned char* buffer, unsigned int offset)
{
BOOST_ASSERT(buffer);
}
TimelinePacketStatus WriteTimelineEventBinaryPacket(uint64_t timestamp,
- uint32_t threadId,
+ std::thread::id threadId,
uint64_t profilingGuid,
unsigned char* buffer,
unsigned int bufferSize,
// Utils
unsigned int uint32_t_size = sizeof(uint32_t);
unsigned int uint64_t_size = sizeof(uint64_t);
+ unsigned int threadId_size = sizeof(std::thread::id);
// decl_id of the timeline message
uint32_t declId = 4;
// Calculate the length of the data (in bytes)
unsigned int timelineEventPacketDataLength = uint32_t_size + // decl_id
uint64_t_size + // Timestamp
- uint32_t_size + // Thread id
+ threadId_size + // Thread id
uint64_t_size; // Profiling GUID
// Calculate the timeline binary packet size (in bytes)
offset += uint32_t_size;
WriteUint64(buffer, offset, timestamp); // Timestamp
offset += uint64_t_size;
- WriteUint32(buffer, offset, threadId); // Thread id
- offset += uint32_t_size;
+ WriteBytes(buffer, offset, &threadId, threadId_size); // Thread id
+ offset += threadId_size;
WriteUint64(buffer, offset, profilingGuid); // Profiling GUID
offset += uint64_t_size;
} // namespace profiling
} // namespace armnn
+
+namespace std
+{
+
+bool operator==(const std::vector<uint8_t>& left, std::thread::id right)
+{
+ return std::memcmp(left.data(), &right, left.size()) == 0;
+}
+
+} // namespace std
#include <memory>
#include <string>
#include <vector>
+#include <thread>
namespace armnn
{
std::vector<uint16_t> GetNextCounterUids(uint16_t cores);
+void WriteBytes(const IPacketBuffer& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize);
+
void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value);
void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value);
void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value);
+void WriteBytes(unsigned char* buffer, unsigned int offset, const void* value, unsigned int valueSize);
+
void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value);
void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value);
void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value);
+void ReadBytes(const IPacketBufferPtr& packetBuffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[]);
+
uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset);
uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset);
uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset);
+void ReadBytes(const unsigned char* buffer, unsigned int offset, unsigned int valueSize, uint8_t outValue[]);
+
uint64_t ReadUint64(unsigned const char* buffer, unsigned int offset);
uint32_t ReadUint32(unsigned const char* buffer, unsigned int offset);
unsigned int& numberOfBytesWritten);
TimelinePacketStatus WriteTimelineEventBinaryPacket(uint64_t timestamp,
- uint32_t threadId,
+ std::thread::id threadId,
uint64_t profilingGuid,
unsigned char* buffer,
unsigned int bufferSize,
} // namespace profiling
} // namespace armnn
+
+namespace std
+{
+
+bool operator==(const std::vector<uint8_t>& left, std::thread::id right);
+
+} // namespace std
m_BufferSize);
}
-void SendTimelinePacket::SendTimelineEventBinaryPacket(uint64_t timestamp, uint32_t threadId, uint64_t profilingGuid)
+void SendTimelinePacket::SendTimelineEventBinaryPacket(uint64_t timestamp,
+ std::thread::id threadId,
+ uint64_t profilingGuid)
{
FORWARD_WRITE_BINARY_FUNC(WriteTimelineEventBinaryPacket,
timestamp,
void SendTimelineEntityBinaryPacket(uint64_t profilingGuid) override;
/// Create and write a TimelineEventBinaryPacket from the parameters to the buffer.
- void SendTimelineEventBinaryPacket(uint64_t timestamp, uint32_t threadId, uint64_t profilingGuid) override;
+ void SendTimelineEventBinaryPacket(uint64_t timestamp, std::thread::id threadId, uint64_t profilingGuid) override;
/// Create and write a TimelineEventClassBinaryPacket from the parameters to the buffer.
void SendTimelineEventClassBinaryPacket(uint64_t profilingGuid) override;
{
unsigned int uint32_t_size = sizeof(uint32_t);
unsigned int uint64_t_size = sizeof(uint64_t);
+ unsigned int threadId_size = sizeof(std::thread::id);
MockBufferManager bufferManager(512);
TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager);
// Send TimelineEventBinaryPacket
const uint64_t timestamp = 456789u;
- const uint32_t threadId = 654321u;
+ const std::thread::id threadId = std::this_thread::get_id();
const uint64_t eventProfilingGuid = 123456u;
sendTimelinePacket->SendTimelineEventBinaryPacket(timestamp, threadId, eventProfilingGuid);
uint32_t eventBinaryPacketSequenceNumbered = (eventBinaryPacketHeaderWord1 >> 24) & 0x00000001;
uint32_t eventBinaryPacketDataLength = (eventBinaryPacketHeaderWord1 >> 0) & 0x00FFFFFF;
BOOST_CHECK(eventBinaryPacketSequenceNumbered == 0);
- BOOST_CHECK(eventBinaryPacketDataLength == 24);
+ BOOST_CHECK(eventBinaryPacketDataLength == 28);
// Check the decl_id
offset += uint32_t_size;
// Check the thread id
offset += uint64_t_size;
- uint32_t readThreadId = ReadUint32(packetBuffer, offset);
+ std::vector<uint8_t> readThreadId(threadId_size, 0);
+ ReadBytes(packetBuffer, offset, threadId_size, readThreadId.data());
BOOST_CHECK(readThreadId == threadId);
// Check the profiling GUID
- offset += uint32_t_size;
+ offset += threadId_size;
readProfilingGuid = ReadUint64(packetBuffer, offset);
BOOST_CHECK(readProfilingGuid == eventProfilingGuid);
}
BOOST_AUTO_TEST_CASE(TimelineEventPacketTest1)
{
const uint64_t timestamp = 456789u;
- const uint32_t threadId = 654321u;
+ const std::thread::id threadId = std::this_thread::get_id();
const uint64_t profilingGuid = 123456u;
unsigned int numberOfBytesWritten = 789u;
TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
std::vector<unsigned char> buffer(512, 0);
const uint64_t timestamp = 456789u;
- const uint32_t threadId = 654321u;
+ const std::thread::id threadId = std::this_thread::get_id();
const uint64_t profilingGuid = 123456u;
unsigned int numberOfBytesWritten = 789u;
TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
std::vector<unsigned char> buffer(10, 0);
const uint64_t timestamp = 456789u;
- const uint32_t threadId = 654321u;
+ const std::thread::id threadId = std::this_thread::get_id();
const uint64_t profilingGuid = 123456u;
unsigned int numberOfBytesWritten = 789u;
TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
std::vector<unsigned char> buffer(512, 0);
const uint64_t timestamp = 456789u;
- const uint32_t threadId = 654321u;
+ const std::thread::id threadId = std::this_thread::get_id();
const uint64_t profilingGuid = 123456u;
unsigned int numberOfBytesWritten = 789u;
TimelinePacketStatus result = WriteTimelineEventBinaryPacket(timestamp,
boost::numeric_cast<unsigned int>(buffer.size()),
numberOfBytesWritten);
BOOST_CHECK(result == TimelinePacketStatus::Ok);
- BOOST_CHECK(numberOfBytesWritten == 32);
+ BOOST_CHECK(numberOfBytesWritten == 36);
unsigned int uint32_t_size = sizeof(uint32_t);
unsigned int uint64_t_size = sizeof(uint64_t);
+ unsigned int threadId_size = sizeof(std::thread::id);
// Check the packet header
unsigned int offset = 0;
uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001;
uint32_t dataLength = (packetHeaderWord1 >> 0) & 0x00FFFFFF;
BOOST_CHECK(sequenceNumbered == 0);
- BOOST_CHECK(dataLength == 24);
+ BOOST_CHECK(dataLength == 28);
// Check the decl_id
offset += uint32_t_size;
// Check the thread id
offset += uint64_t_size;
- uint32_t readThreadId = ReadUint32(buffer.data(), offset);
+ std::vector<uint8_t> readThreadId(threadId_size, 0);
+ ReadBytes(buffer.data(), offset, threadId_size, readThreadId.data());
BOOST_CHECK(readThreadId == threadId);
// Check the profiling GUID
- offset += uint32_t_size;
+ offset += threadId_size;
uint64_t readProfilingGuid = ReadUint64(buffer.data(), offset);
BOOST_CHECK(readProfilingGuid == profilingGuid);
}