public:
PeriodicCounterCapture(const Holder& data,
ISendCounterPacket& packet,
- const IReadCounterValues& readCounterValue,
+ IReadCounterValues& readCounterValue,
const ICounterMappings& counterIdMap,
const std::unordered_map<armnn::BackendId,
std::shared_ptr<armnn::profiling::IBackendProfilingContext>>&
private:
CaptureData ReadCaptureData();
- void Capture(const IReadCounterValues& readCounterValues);
+ void Capture(IReadCounterValues& readCounterValues);
void DispatchPeriodicCounterCapturePacket(
const armnn::BackendId& backendId, const std::vector<Timestamp>& timestampValues);
bool m_IsRunning;
std::atomic<bool> m_KeepRunning;
std::thread m_PeriodCaptureThread;
- const IReadCounterValues& m_ReadCounterValues;
+ IReadCounterValues& m_ReadCounterValues;
ISendCounterPacket& m_SendCounterPacket;
const ICounterMappings& m_CounterIdMap;
const std::unordered_map<armnn::BackendId,
return counterUid < m_CounterIndex.size();
}
-uint32_t ProfilingService::GetCounterValue(uint16_t counterUid) const
+uint32_t ProfilingService::GetAbsoluteCounterValue(uint16_t counterUid) const
{
CheckCounterUid(counterUid);
std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
return counterValuePtr->load(std::memory_order::memory_order_relaxed);
}
+uint32_t ProfilingService::GetDeltaCounterValue(uint16_t counterUid)
+{
+ CheckCounterUid(counterUid);
+ std::atomic<uint32_t>* counterValuePtr = m_CounterIndex.at(counterUid);
+ ARMNN_ASSERT(counterValuePtr);
+ const uint32_t counterValue = counterValuePtr->load(std::memory_order::memory_order_relaxed);
+ SubtractCounterValue(counterUid, counterValue);
+ return counterValue;
+}
+
const ICounterMappings& ProfilingService::GetCounterMappings() const
{
return m_CounterIdMap;
m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
armnn::profiling::NETWORK_LOADS,
"ArmNN_Runtime",
- 1,
+ 0,
0,
1.f,
"Network loads",
m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
armnn::profiling::NETWORK_UNLOADS,
"ArmNN_Runtime",
- 1,
+ 0,
0,
1.f,
"Network unloads",
m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
armnn::profiling::REGISTERED_BACKENDS,
"ArmNN_Runtime",
- 1,
+ 0,
0,
1.f,
"Backends registered",
m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
armnn::profiling::UNREGISTERED_BACKENDS,
"ArmNN_Runtime",
- 1,
+ 0,
0,
1.f,
"Backends unregistered",
m_CounterDirectory.RegisterCounter(armnn::profiling::BACKEND_ID,
armnn::profiling::INFERENCES_RUN,
"ArmNN_Runtime",
- 1,
+ 0,
0,
1.f,
"Inferences run",
const Counters& counters = counterDirectory.GetCounters();
BOOST_CHECK(!counters.empty());
- // Get the UID of the first counter for testing;
-
- ProfilingService* profilingServicePtr = &profilingService;
std::vector<std::thread> writers;
- for (int i = 0; i < 10; ++i)
+ BOOST_CHECK(!counters.empty());
+
+ // Test GetAbsoluteCounterValue
+ for (int i = 0; i < 4; ++i)
{
- // Increment and decrement the first counter
- writers.push_back(std::thread(&ProfilingService::IncrementCounterValue,
- profilingServicePtr,
- armnn::profiling::REGISTERED_BACKENDS));
-
- writers.push_back(std::thread(&ProfilingService::IncrementCounterValue,
- profilingServicePtr,
- armnn::profiling::UNREGISTERED_BACKENDS));
-
- // Add 10 and subtract 5 from the first counter
- writers.push_back(std::thread(&ProfilingService::AddCounterValue,
- profilingServicePtr,
- armnn::profiling::INFERENCES_RUN,
- 10));
- writers.push_back(std::thread(&ProfilingService::SubtractCounterValue,
- profilingServicePtr,
- armnn::profiling::INFERENCES_RUN,
- 5));
+ // Increment and decrement the INFERENCES_RUN counter 250 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 250; ++i)
+ {
+ profilingService.IncrementCounterValue(INFERENCES_RUN);
+ }
+ }));
+ // Add 10 to the INFERENCES_RUN counter 200 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 200; ++i)
+ {
+ profilingService.AddCounterValue(INFERENCES_RUN, 10);
+ }
+ }));
+ // Subtract 5 from the INFERENCES_RUN counter 200 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 200; ++i)
+ {
+ profilingService.SubtractCounterValue(INFERENCES_RUN, 5);
+ }
+ }));
}
+
std::for_each(writers.begin(), writers.end(), mem_fn(&std::thread::join));
- uint32_t counterValue = 0;
- BOOST_CHECK(counterValue ==
- (profilingService.GetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS)
- - profilingService.GetCounterValue(armnn::profiling::REGISTERED_BACKENDS)));
- BOOST_CHECK(profilingService.GetCounterValue(armnn::profiling::INFERENCES_RUN) == 50);
+ uint32_t absoluteCounterValue = 0;
+
+ BOOST_CHECK_NO_THROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
+ BOOST_CHECK(absoluteCounterValue = 5000);
+
+ // Test SetCounterValue
+ BOOST_CHECK_NO_THROW(profilingService.SetCounterValue(INFERENCES_RUN, 0));
+ BOOST_CHECK_NO_THROW(absoluteCounterValue = profilingService.GetAbsoluteCounterValue(INFERENCES_RUN));
+ BOOST_CHECK(absoluteCounterValue == 0);
+
+ // Test GetDeltaCounterValue
+ writers.clear();
+ uint32_t deltaCounterValue = 0;
+ //Start a reading thread to randomly read the INFERENCES_RUN counter value
+ std::thread reader([&profilingService](uint32_t& deltaCounterValue)
+ {
+ for (int i = 0; i < 300; ++i)
+ {
+ deltaCounterValue += profilingService.GetDeltaCounterValue(INFERENCES_RUN);
+ }
+ }, std::ref(deltaCounterValue));
+
+ for (int i = 0; i < 4; ++i)
+ {
+ // Increment and decrement the INFERENCES_RUN counter 250 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 250; ++i)
+ {
+ profilingService.IncrementCounterValue(INFERENCES_RUN);
+ }
+ }));
+ // Add 10 to the INFERENCES_RUN counter 200 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 200; ++i)
+ {
+ profilingService.AddCounterValue(INFERENCES_RUN, 10);
+ }
+ }));
+ // Subtract 5 from the INFERENCES_RUN counter 200 times
+ writers.push_back(std::thread([&profilingService]()
+ {
+ for (int i = 0; i < 200; ++i)
+ {
+ profilingService.SubtractCounterValue(INFERENCES_RUN, 5);
+ }
+ }));
+ }
+
+ std::for_each(writers.begin(), writers.end(), mem_fn(&std::thread::join));
+ reader.join();
+
+ // Do one last read in case the reader stopped early
+ deltaCounterValue += profilingService.GetDeltaCounterValue(INFERENCES_RUN);
+ BOOST_CHECK(deltaCounterValue == 5000);
- BOOST_CHECK_NO_THROW(profilingService.SetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS, 4));
- BOOST_CHECK_NO_THROW(counterValue = profilingService.GetCounterValue(armnn::profiling::UNREGISTERED_BACKENDS));
- BOOST_CHECK(counterValue == 4);
// Reset the profiling service to stop any running thread
options.m_EnableProfiling = false;
profilingService.ResetExternalProfilingOptions(options, true);
{
return 0;
}
- uint32_t GetCounterValue(uint16_t counterUid) const override
+ uint32_t GetAbsoluteCounterValue(uint16_t counterUid) const override
+ {
+ armnn::IgnoreUnused(counterUid);
+ return 0;
+ }
+ uint32_t GetDeltaCounterValue(uint16_t counterUid) override
{
armnn::IgnoreUnused(counterUid);
return 0;
return m_CounterSize;
}
- uint32_t GetCounterValue(uint16_t counterUid) const override
+ uint32_t GetAbsoluteCounterValue(uint16_t counterUid) const override
+ {
+ if (counterUid > m_CounterSize)
+ {
+ BOOST_FAIL("Invalid counter Uid");
+ }
+ return m_Data.at(counterUid).load();
+ }
+
+ uint32_t GetDeltaCounterValue(uint16_t counterUid) override
{
if (counterUid > m_CounterSize)
{