10 #include <common/include/Constants.hpp> 13 #include <boost/numeric/conversion/cast.hpp> 37 size_t initialSize = m_PacketQueue.size();
38 for (
size_t i = 0; i < initialSize; ++i)
43 m_KeepRunning.store(
false);
44 if (m_LocalHandlersThread.joinable())
47 m_ConditionPacketReadable.notify_one();
48 m_LocalHandlersThread.join();
52 bool FileOnlyProfilingConnection::WaitForStreamMeta(
const unsigned char* buffer, uint32_t length)
59 Fail(
"Protocol error. The stream_metadata_identifer was not 0.");
73 Fail(
"Protocol read error. Unable to read PIPE_MAGIC value.");
78 void FileOnlyProfilingConnection::SendConnectionAck()
82 std::cout <<
"Sending connection acknowledgement." << std::endl;
84 std::unique_ptr<unsigned char[]> uniqueNullPtr =
nullptr;
86 std::lock_guard<std::mutex> lck(m_PacketAvailableMutex);
87 m_PacketQueue.push(Packet(0x10000, 0, uniqueNullPtr));
89 m_ConditionPacketAvailable.notify_one();
92 bool FileOnlyProfilingConnection::SendCounterSelectionPacket()
98 uint32_t bodySize = uint32_t_size +
boost::numeric_cast<uint32_t>(m_IdList.size()) * uint16_t_size;
100 auto uniqueData = std::make_unique<unsigned char[]>(bodySize);
101 unsigned char* data =
reinterpret_cast<unsigned char*
>(uniqueData.get());
104 WriteUint32(data, offset, m_Options.m_CapturePeriod);
108 for (
const uint16_t&
id : m_IdList)
115 std::lock_guard<std::mutex> lck(m_PacketAvailableMutex);
116 m_PacketQueue.push(Packet(0x40000, bodySize, uniqueData));
118 m_ConditionPacketAvailable.notify_one();
129 uint32_t outgoingHeaderAsWords[2];
130 PackageActivity packageActivity = GetPackageActivity(packet, outgoingHeaderAsWords);
132 switch (packageActivity)
136 if (!WaitForStreamMeta(buffer, length))
146 std::unique_ptr<unsigned char[]> uniqueCounterData = std::make_unique<unsigned char[]>(length - 8);
148 std::memcpy(uniqueCounterData.get(), buffer + 8, length - 8);
150 Packet directoryPacket(outgoingHeaderAsWords[0], length - 8, uniqueCounterData);
155 directoryCaptureCommandHandler.operator()(directoryPacket);
156 const ICounterDirectory& counterDirectory = directoryCaptureCommandHandler.GetCounterDirectory();
160 std::vector<uint16_t> translatedCounters;
161 for (
auto const& copyUid : category->m_Counters)
163 translatedCounters.emplace_back(directoryCaptureCommandHandler.TranslateUIDCopyToOriginal(copyUid));
165 m_IdList.insert(std::end(m_IdList), std::begin(translatedCounters), std::end(translatedCounters));
167 SendCounterSelectionPacket();
175 ForwardPacketToHandlers(packet);
181 std::unique_lock<std::mutex> lck(m_PacketAvailableMutex);
185 if(!m_ConditionPacketAvailable.wait_for(lck,
186 std::chrono::milliseconds(timeout),
187 [&]{return !m_PacketQueue.empty();}))
192 Packet returnedPacket = std::move(m_PacketQueue.front());
194 return returnedPacket;
197 PackageActivity FileOnlyProfilingConnection::GetPackageActivity(
const Packet& packet, uint32_t headerAsWords[2])
199 headerAsWords[0] = packet.GetHeader();
200 headerAsWords[1] = packet.GetLength();
201 if (headerAsWords[0] == 0x20000)
205 else if (headerAsWords[0] == 0)
215 uint32_t FileOnlyProfilingConnection::ToUint32(
const unsigned char* data,
TargetEndianness endianness)
221 return static_cast<uint32_t
>(data[0]) << 24 | static_cast<uint32_t>(data[1]) << 16 |
222 static_cast<uint32_t
>(data[2]) << 8 | static_cast<uint32_t>(data[3]);
226 return static_cast<uint32_t
>(data[3]) << 24 | static_cast<uint32_t>(data[2]) << 16 |
227 static_cast<uint32_t
>(data[1]) << 8 | static_cast<uint32_t>(data[0]);
231 void FileOnlyProfilingConnection::Fail(
const std::string& errorMessage)
243 m_PacketHandlers.push_back(std::move(localPacketHandler));
245 localCopy->SetConnection(
this);
246 if (localCopy->GetHeadersAccepted().empty())
249 m_UniversalHandlers.push_back(localCopy);
253 for (uint32_t header : localCopy->GetHeadersAccepted())
255 auto iter = m_IndexedHandlers.find(header);
256 if (iter == m_IndexedHandlers.end())
258 std::vector<ILocalPacketHandlerSharedPtr> handlers;
259 handlers.push_back(localCopy);
260 m_IndexedHandlers.emplace(std::make_pair(header, handlers));
264 iter->second.push_back(localCopy);
270 void FileOnlyProfilingConnection::StartProcessingThread()
273 if (m_IsRunning.load())
278 if (m_LocalHandlersThread.joinable())
280 m_LocalHandlersThread.join();
282 m_IsRunning.store(
true);
283 m_KeepRunning.store(
true);
284 m_LocalHandlersThread = std::thread(&FileOnlyProfilingConnection::ServiceLocalHandlers,
this);
287 void FileOnlyProfilingConnection::ForwardPacketToHandlers(Packet& packet)
289 if (m_PacketHandlers.empty())
293 if (m_KeepRunning.load() ==
false)
298 std::unique_lock<std::mutex> readableListLock(m_ReadableMutex);
299 if (m_KeepRunning.load() ==
false)
303 m_ReadableList.push(std::move(packet));
305 m_ConditionPacketReadable.notify_one();
308 void FileOnlyProfilingConnection::ServiceLocalHandlers()
312 Packet returnedPacket;
313 bool readPacket =
false;
315 std::unique_lock<std::mutex> lck(m_ReadableMutex);
318 m_ConditionPacketReadable.wait(lck,
319 [&] {
return !m_ReadableList.empty(); });
323 m_ConditionPacketReadable.wait_for(lck,
324 std::chrono::milliseconds(std::max(m_Timeout, 1000)),
325 [&] {
return !m_ReadableList.empty(); });
327 if (m_KeepRunning.load())
329 if (!m_ReadableList.empty())
331 returnedPacket = std::move(m_ReadableList.front());
332 m_ReadableList.pop();
341 if (m_KeepRunning.load() && readPacket)
343 DispatchPacketToHandlers(returnedPacket);
345 }
while (m_KeepRunning.load());
348 m_IsRunning.store(
false);
351 void FileOnlyProfilingConnection::ClearReadableList()
354 size_t initialSize = m_ReadableList.size();
355 for (
size_t i = 0; i < initialSize; ++i)
357 m_ReadableList.pop();
361 void FileOnlyProfilingConnection::DispatchPacketToHandlers(
const Packet& packet)
363 for (
auto& delegate : m_UniversalHandlers)
365 delegate->HandlePacket(packet);
367 auto iter = m_IndexedHandlers.find(packet.GetHeader());
368 if (iter != m_IndexedHandlers.end())
370 for (
auto &delegate : iter->second)
372 delegate->HandlePacket(packet);
uint32_t GetEncodedValue()
std::shared_ptr< ILocalPacketHandler > ILocalPacketHandlerSharedPtr
void WriteUint16(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint16_t value)
void WriteUint32(const IPacketBufferPtr &packetBuffer, unsigned int offset, uint32_t value)
Version ResolvePacketVersion(uint32_t familyId, uint32_t packetId) const
bool IsOpen() const override
Copyright (c) 2020 ARM Limited.
void IgnoreUnused(Ts &&...)
virtual const Categories & GetCategories() const =0
#define ARMNN_ASSERT(COND)
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Packet ReceivePacket(const unsigned char *buffer, uint32_t length)
~FileOnlyProfilingConnection()
bool WritePacket(const unsigned char *buffer, uint32_t length) override
Packet ReadPacket(uint32_t timeout) override