1 //
2 // Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5
6 #include "CounterDirectory.hpp"
7 #include "CounterIdMap.hpp"
8 #include "Holder.hpp"
9 #include "MockBackend.hpp"
10 #include "MockBackendId.hpp"
11 #include "PeriodicCounterCapture.hpp"
12 #include "PeriodicCounterSelectionCommandHandler.hpp"
13 #include "ProfilingStateMachine.hpp"
14 #include "ProfilingUtils.hpp"
15 #include "RequestCounterDirectoryCommandHandler.hpp"
16
17 #include <test/TestUtils.hpp>
18
19 #include <armnn/utility/IgnoreUnused.hpp>
20 #include <armnn/BackendId.hpp>
21 #include <armnn/Logging.hpp>
22 #include <armnn/profiling/ISendTimelinePacket.hpp>
23
24 #include <boost/test/unit_test.hpp>
25 #include <vector>
26
27 #include <cstdint>
28 #include <limits>
29 #include <backends/BackendProfiling.hpp>
30
31 using namespace armnn::profiling;
32
33 class ReadCounterVals : public IReadCounterValues
34 {
IsCounterRegistered(uint16_t counterUid) const35 virtual bool IsCounterRegistered(uint16_t counterUid) const override
36 {
37 return (counterUid > 4 && counterUid < 11);
38 }
GetCounterCount() const39 virtual uint16_t GetCounterCount() const override
40 {
41 return 1;
42 }
GetAbsoluteCounterValue(uint16_t counterUid) const43 virtual uint32_t GetAbsoluteCounterValue(uint16_t counterUid) const override
44 {
45 return counterUid;
46 }
GetDeltaCounterValue(uint16_t counterUid)47 virtual uint32_t GetDeltaCounterValue(uint16_t counterUid) override
48 {
49 return counterUid;
50 }
51 };
52
53 class MockBackendSendCounterPacket : public ISendCounterPacket
54 {
55 public:
56 using IndexValuePairsVector = std::vector<CounterValue>;
57
58 /// Create and write a StreamMetaDataPacket in the buffer
SendStreamMetaDataPacket()59 virtual void SendStreamMetaDataPacket() {}
60
61 /// Create and write a CounterDirectoryPacket from the parameters to the buffer.
SendCounterDirectoryPacket(const ICounterDirectory & counterDirectory)62 virtual void SendCounterDirectoryPacket(const ICounterDirectory& counterDirectory)
63 {
64 armnn::IgnoreUnused(counterDirectory);
65 }
66
67 /// Create and write a PeriodicCounterCapturePacket from the parameters to the buffer.
SendPeriodicCounterCapturePacket(uint64_t timestamp,const IndexValuePairsVector & values)68 virtual void SendPeriodicCounterCapturePacket(uint64_t timestamp, const IndexValuePairsVector& values)
69 {
70 m_timestamps.emplace_back(Timestamp{timestamp, values});
71 }
72
73 /// Create and write a PeriodicCounterSelectionPacket from the parameters to the buffer.
SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,const std::vector<uint16_t> & selectedCounterIds)74 virtual void SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,
75 const std::vector<uint16_t>& selectedCounterIds)
76 {
77 armnn::IgnoreUnused(capturePeriod);
78 armnn::IgnoreUnused(selectedCounterIds);
79 }
80
GetTimestamps()81 std::vector<Timestamp> GetTimestamps()
82 {
83 return m_timestamps;
84 }
85
ClearTimestamps()86 void ClearTimestamps()
87 {
88 m_timestamps.clear();
89 }
90
91 private:
92 std::vector<Timestamp> m_timestamps;
93 };
94
PacketWriter(uint32_t period,std::vector<uint16_t> countervalues)95 arm::pipe::Packet PacketWriter(uint32_t period, std::vector<uint16_t> countervalues)
96 {
97 const uint32_t packetId = 0x40000;
98 uint32_t offset = 0;
99 uint32_t dataLength = static_cast<uint32_t>(4 + countervalues.size() * 2);
100 std::unique_ptr<unsigned char[]> uniqueData = std::make_unique<unsigned char[]>(dataLength);
101 unsigned char* data1 = reinterpret_cast<unsigned char*>(uniqueData.get());
102
103 WriteUint32(data1, offset, period);
104 offset += 4;
105 for (auto countervalue : countervalues)
106 {
107 WriteUint16(data1, offset, countervalue);
108 offset += 2;
109 }
110
111 return {packetId, dataLength, uniqueData};
112 }
113
114 BOOST_AUTO_TEST_SUITE(BackendProfilingTestSuite)
115
BOOST_AUTO_TEST_CASE(BackendProfilingCounterRegisterMockBackendTest)116 BOOST_AUTO_TEST_CASE(BackendProfilingCounterRegisterMockBackendTest)
117 {
118 // Reset the profiling service to the uninitialized state
119 armnn::IRuntime::CreationOptions options;
120 options.m_ProfilingOptions.m_EnableProfiling = true;
121
122 armnn::MockBackendInitialiser initialiser;
123 // Create a runtime
124 armnn::Runtime runtime(options);
125
126 unsigned int shiftedId = 0;
127
128 #if defined(ETHOSN_SUPPORT_ENABLED)
129 // Shift the id as ETHOSN is enabled.
130 shiftedId = 4;
131 #endif
132
133 // Check if the MockBackends 3 dummy counters {0, 1, 2-5 (four cores)} are registered
134 armnn::BackendId mockId = armnn::MockBackendId();
135 const armnn::profiling::ICounterMappings& counterMap = GetProfilingService(&runtime).GetCounterMappings();
136 BOOST_CHECK(counterMap.GetGlobalId(0, mockId) == 5 + shiftedId);
137 BOOST_CHECK(counterMap.GetGlobalId(1, mockId) == 6 + shiftedId);
138 BOOST_CHECK(counterMap.GetGlobalId(2, mockId) == 7 + shiftedId);
139 BOOST_CHECK(counterMap.GetGlobalId(3, mockId) == 8 + shiftedId);
140 BOOST_CHECK(counterMap.GetGlobalId(4, mockId) == 9 + shiftedId);
141 BOOST_CHECK(counterMap.GetGlobalId(5, mockId) == 10 + shiftedId);
142 options.m_ProfilingOptions.m_EnableProfiling = false;
143 GetProfilingService(&runtime).ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
144 }
145
BOOST_AUTO_TEST_CASE(TestBackendCounters)146 BOOST_AUTO_TEST_CASE(TestBackendCounters)
147 {
148 Holder holder;
149 arm::pipe::PacketVersionResolver packetVersionResolver;
150 ProfilingStateMachine stateMachine;
151 ReadCounterVals readCounterVals;
152 CounterIdMap counterIdMap;
153 MockBackendSendCounterPacket sendCounterPacket;
154
155 const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
156 const armnn::BackendId gpuAccId(armnn::Compute::GpuAcc);
157
158 armnn::IRuntime::CreationOptions options;
159 options.m_ProfilingOptions.m_EnableProfiling = true;
160
161 armnn::profiling::ProfilingService profilingService;
162
163 std::unique_ptr<armnn::profiling::IBackendProfiling> cpuBackendProfilingPtr =
164 std::make_unique<BackendProfiling>(options, profilingService, cpuAccId);
165 std::unique_ptr<armnn::profiling::IBackendProfiling> gpuBackendProfilingPtr =
166 std::make_unique<BackendProfiling>(options, profilingService, gpuAccId);
167
168 std::shared_ptr<armnn::profiling::IBackendProfilingContext> cpuProfilingContextPtr =
169 std::make_shared<armnn::MockBackendProfilingContext>(cpuBackendProfilingPtr);
170 std::shared_ptr<armnn::profiling::IBackendProfilingContext> gpuProfilingContextPtr =
171 std::make_shared<armnn::MockBackendProfilingContext>(gpuBackendProfilingPtr);
172
173 std::unordered_map<armnn::BackendId,
174 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContexts;
175
176 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
177 backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
178
179 uint16_t globalId = 5;
180
181 counterIdMap.RegisterMapping(globalId++, 0, cpuAccId);
182 counterIdMap.RegisterMapping(globalId++, 1, cpuAccId);
183 counterIdMap.RegisterMapping(globalId++, 2, cpuAccId);
184
185 counterIdMap.RegisterMapping(globalId++, 0, gpuAccId);
186 counterIdMap.RegisterMapping(globalId++, 1, gpuAccId);
187 counterIdMap.RegisterMapping(globalId++, 2, gpuAccId);
188
189 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
190 backendProfilingContexts[gpuAccId] = gpuProfilingContextPtr;
191
192 PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
193 counterIdMap, backendProfilingContexts);
194
195 uint16_t maxArmnnCounterId = 4;
196
197 PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
198 4,
199 packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
200 backendProfilingContexts,
201 counterIdMap,
202 holder,
203 maxArmnnCounterId,
204 periodicCounterCapture,
205 readCounterVals,
206 sendCounterPacket,
207 stateMachine);
208
209 stateMachine.TransitionToState(ProfilingState::NotConnected);
210 stateMachine.TransitionToState(ProfilingState::WaitingForAck);
211 stateMachine.TransitionToState(ProfilingState::Active);
212
213 uint32_t period = 12345u;
214
215 std::vector<uint16_t> cpuCounters{5, 6, 7};
216 std::vector<uint16_t> gpuCounters{8, 9, 10};
217
218 // Request only gpu counters
219 periodicCounterSelectionCommandHandler(PacketWriter(period, gpuCounters));
220 periodicCounterCapture.Stop();
221
222 std::set<armnn::BackendId> activeIds = holder.GetCaptureData().GetActiveBackends();
223 BOOST_CHECK(activeIds.size() == 1);
224 BOOST_CHECK(activeIds.find(gpuAccId) != activeIds.end());
225
226 std::vector<Timestamp> recievedTimestamp = sendCounterPacket.GetTimestamps();
227
228 BOOST_CHECK(recievedTimestamp[0].timestamp == period);
229 BOOST_CHECK(recievedTimestamp.size() == 1);
230 BOOST_CHECK(recievedTimestamp[0].counterValues.size() == gpuCounters.size());
231 for (unsigned long i=0; i< gpuCounters.size(); ++i)
232 {
233 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterId == gpuCounters[i]);
234 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
235 }
236 sendCounterPacket.ClearTimestamps();
237
238 // Request only cpu counters
239 periodicCounterSelectionCommandHandler(PacketWriter(period, cpuCounters));
240 periodicCounterCapture.Stop();
241
242 activeIds = holder.GetCaptureData().GetActiveBackends();
243 BOOST_CHECK(activeIds.size() == 1);
244 BOOST_CHECK(activeIds.find(cpuAccId) != activeIds.end());
245
246 recievedTimestamp = sendCounterPacket.GetTimestamps();
247
248 BOOST_CHECK(recievedTimestamp[0].timestamp == period);
249 BOOST_CHECK(recievedTimestamp.size() == 1);
250 BOOST_CHECK(recievedTimestamp[0].counterValues.size() == cpuCounters.size());
251 for (unsigned long i=0; i< cpuCounters.size(); ++i)
252 {
253 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
254 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
255 }
256 sendCounterPacket.ClearTimestamps();
257
258 // Request combination of cpu & gpu counters with new period
259 period = 12222u;
260 periodicCounterSelectionCommandHandler(PacketWriter(period, {cpuCounters[0], gpuCounters[2],
261 gpuCounters[1], cpuCounters[1], gpuCounters[0]}));
262 periodicCounterCapture.Stop();
263
264 activeIds = holder.GetCaptureData().GetActiveBackends();
265 BOOST_CHECK(activeIds.size() == 2);
266 BOOST_CHECK(activeIds.find(cpuAccId) != activeIds.end());
267 BOOST_CHECK(activeIds.find(gpuAccId) != activeIds.end());
268
269 recievedTimestamp = sendCounterPacket.GetTimestamps();
270
271 BOOST_CHECK(recievedTimestamp[0].timestamp == period);
272 BOOST_CHECK(recievedTimestamp[1].timestamp == period);
273
274 BOOST_CHECK(recievedTimestamp.size() == 2);
275 BOOST_CHECK(recievedTimestamp[0].counterValues.size() == 2);
276 BOOST_CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
277
278 BOOST_CHECK(recievedTimestamp[0].counterValues[0].counterId == cpuCounters[0]);
279 BOOST_CHECK(recievedTimestamp[0].counterValues[0].counterValue == 1u);
280 BOOST_CHECK(recievedTimestamp[0].counterValues[1].counterId == cpuCounters[1]);
281 BOOST_CHECK(recievedTimestamp[0].counterValues[1].counterValue == 2u);
282
283 for (unsigned long i=0; i< gpuCounters.size(); ++i)
284 {
285 BOOST_CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
286 BOOST_CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
287 }
288
289 sendCounterPacket.ClearTimestamps();
290
291 // Request all counters
292 std::vector<uint16_t> counterValues;
293 counterValues.insert(counterValues.begin(), cpuCounters.begin(), cpuCounters.end());
294 counterValues.insert(counterValues.begin(), gpuCounters.begin(), gpuCounters.end());
295
296 periodicCounterSelectionCommandHandler(PacketWriter(period, counterValues));
297 periodicCounterCapture.Stop();
298
299 activeIds = holder.GetCaptureData().GetActiveBackends();
300 BOOST_CHECK(activeIds.size() == 2);
301 BOOST_CHECK(activeIds.find(cpuAccId) != activeIds.end());
302 BOOST_CHECK(activeIds.find(gpuAccId) != activeIds.end());
303
304 recievedTimestamp = sendCounterPacket.GetTimestamps();
305
306 BOOST_CHECK(recievedTimestamp[0].counterValues.size() == cpuCounters.size());
307 for (unsigned long i=0; i< cpuCounters.size(); ++i)
308 {
309 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterId == cpuCounters[i]);
310 BOOST_CHECK(recievedTimestamp[0].counterValues[i].counterValue == i + 1u);
311 }
312
313 BOOST_CHECK(recievedTimestamp[1].counterValues.size() == gpuCounters.size());
314 for (unsigned long i=0; i< gpuCounters.size(); ++i)
315 {
316 BOOST_CHECK(recievedTimestamp[1].counterValues[i].counterId == gpuCounters[i]);
317 BOOST_CHECK(recievedTimestamp[1].counterValues[i].counterValue == i + 1u);
318 }
319 sendCounterPacket.ClearTimestamps();
320
321 // Request random counters with duplicates and invalid counters
322 counterValues = {0, 0, 200, cpuCounters[2], gpuCounters[0],3 ,30, cpuCounters[0],cpuCounters[2], gpuCounters[1], 3,
323 90, 0, 30, gpuCounters[0], gpuCounters[0]};
324
325 periodicCounterSelectionCommandHandler(PacketWriter(period, counterValues));
326 periodicCounterCapture.Stop();
327
328 activeIds = holder.GetCaptureData().GetActiveBackends();
329 BOOST_CHECK(activeIds.size() == 2);
330 BOOST_CHECK(activeIds.find(cpuAccId) != activeIds.end());
331 BOOST_CHECK(activeIds.find(gpuAccId) != activeIds.end());
332
333 recievedTimestamp = sendCounterPacket.GetTimestamps();
334
335 BOOST_CHECK(recievedTimestamp.size() == 2);
336
337 BOOST_CHECK(recievedTimestamp[0].counterValues.size() == 2);
338
339 BOOST_CHECK(recievedTimestamp[0].counterValues[0].counterId == cpuCounters[0]);
340 BOOST_CHECK(recievedTimestamp[0].counterValues[0].counterValue == 1u);
341 BOOST_CHECK(recievedTimestamp[0].counterValues[1].counterId == cpuCounters[2]);
342 BOOST_CHECK(recievedTimestamp[0].counterValues[1].counterValue == 3u);
343
344 BOOST_CHECK(recievedTimestamp[1].counterValues.size() == 2);
345
346 BOOST_CHECK(recievedTimestamp[1].counterValues[0].counterId == gpuCounters[0]);
347 BOOST_CHECK(recievedTimestamp[1].counterValues[0].counterValue == 1u);
348 BOOST_CHECK(recievedTimestamp[1].counterValues[1].counterId == gpuCounters[1]);
349 BOOST_CHECK(recievedTimestamp[1].counterValues[1].counterValue == 2u);
350
351 sendCounterPacket.ClearTimestamps();
352
353 // Request no counters
354 periodicCounterSelectionCommandHandler(PacketWriter(period, {}));
355 periodicCounterCapture.Stop();
356
357 activeIds = holder.GetCaptureData().GetActiveBackends();
358 BOOST_CHECK(activeIds.size() == 0);
359
360 recievedTimestamp = sendCounterPacket.GetTimestamps();
361 BOOST_CHECK(recievedTimestamp.size() == 0);
362
363 sendCounterPacket.ClearTimestamps();
364
365 // Request period of zero
366 periodicCounterSelectionCommandHandler(PacketWriter(0, counterValues));
367 periodicCounterCapture.Stop();
368
369 activeIds = holder.GetCaptureData().GetActiveBackends();
370 BOOST_CHECK(activeIds.size() == 0);
371
372 recievedTimestamp = sendCounterPacket.GetTimestamps();
373 BOOST_CHECK(recievedTimestamp.size() == 0);
374 }
375
BOOST_AUTO_TEST_CASE(TestBackendCounterLogging)376 BOOST_AUTO_TEST_CASE(TestBackendCounterLogging)
377 {
378 std::stringstream ss;
379
380 struct StreamRedirector
381 {
382 public:
383 StreamRedirector(std::ostream &stream, std::streambuf *newStreamBuffer)
384 : m_Stream(stream), m_BackupBuffer(m_Stream.rdbuf(newStreamBuffer))
385 {}
386
387 ~StreamRedirector()
388 { m_Stream.rdbuf(m_BackupBuffer); }
389
390 private:
391 std::ostream &m_Stream;
392 std::streambuf *m_BackupBuffer;
393 };
394
395 Holder holder;
396 arm::pipe::PacketVersionResolver packetVersionResolver;
397 ProfilingStateMachine stateMachine;
398 ReadCounterVals readCounterVals;
399 StreamRedirector redirect(std::cout, ss.rdbuf());
400 CounterIdMap counterIdMap;
401 MockBackendSendCounterPacket sendCounterPacket;
402
403 const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
404 const armnn::BackendId gpuAccId(armnn::Compute::GpuAcc);
405
406 armnn::IRuntime::CreationOptions options;
407 options.m_ProfilingOptions.m_EnableProfiling = true;
408
409 armnn::profiling::ProfilingService profilingService;
410
411 std::unique_ptr<armnn::profiling::IBackendProfiling> cpuBackendProfilingPtr =
412 std::make_unique<BackendProfiling>(options, profilingService, cpuAccId);
413
414 std::shared_ptr<armnn::profiling::IBackendProfilingContext> cpuProfilingContextPtr =
415 std::make_shared<armnn::MockBackendProfilingContext>(cpuBackendProfilingPtr);
416
417 std::unordered_map<armnn::BackendId,
418 std::shared_ptr<armnn::profiling::IBackendProfilingContext>> backendProfilingContexts;
419
420 uint16_t globalId = 5;
421 counterIdMap.RegisterMapping(globalId, 0, cpuAccId);
422 backendProfilingContexts[cpuAccId] = cpuProfilingContextPtr;
423
424 PeriodicCounterCapture periodicCounterCapture(holder, sendCounterPacket, readCounterVals,
425 counterIdMap, backendProfilingContexts);
426
427 uint16_t maxArmnnCounterId = 4;
428
429 PeriodicCounterSelectionCommandHandler periodicCounterSelectionCommandHandler(0,
430 4,
431 packetVersionResolver.ResolvePacketVersion(0, 4).GetEncodedValue(),
432 backendProfilingContexts,
433 counterIdMap,
434 holder,
435 maxArmnnCounterId,
436 periodicCounterCapture,
437 readCounterVals,
438 sendCounterPacket,
439 stateMachine);
440
441 stateMachine.TransitionToState(ProfilingState::NotConnected);
442 stateMachine.TransitionToState(ProfilingState::WaitingForAck);
443 stateMachine.TransitionToState(ProfilingState::Active);
444
445 uint32_t period = 15939u;
446
447 armnn::SetAllLoggingSinks(true, false, false);
448 SetLogFilter(armnn::LogSeverity::Warning);
449 periodicCounterSelectionCommandHandler(PacketWriter(period, {5}));
450 periodicCounterCapture.Stop();
451 SetLogFilter(armnn::LogSeverity::Fatal);
452
453 BOOST_CHECK(ss.str().find("ActivateCounters example test error") != std::string::npos);
454 }
455
BOOST_AUTO_TEST_CASE(BackendProfilingContextGetSendTimelinePacket)456 BOOST_AUTO_TEST_CASE(BackendProfilingContextGetSendTimelinePacket)
457 {
458 // Reset the profiling service to the uninitialized state
459 armnn::IRuntime::CreationOptions options;
460 options.m_ProfilingOptions.m_EnableProfiling = true;
461 armnn::profiling::ProfilingService profilingService;
462 profilingService.ConfigureProfilingService(options.m_ProfilingOptions, true);
463
464 armnn::MockBackendInitialiser initialiser;
465 // Create a runtime. During this the mock backend will be registered and context returned.
466 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
467 armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
468 armnn::MockBackendProfilingContext *mockBackEndProfilingContext = mockProfilingService.GetContext();
469 // Check that there is a valid context set.
470 BOOST_CHECK(mockBackEndProfilingContext);
471 armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
472 mockBackEndProfilingContext->GetBackendProfiling();
473 BOOST_CHECK(backendProfilingIface);
474
475 // Now for the meat of the test. We're just going to send a random packet and make sure there
476 // are no exceptions or errors. The sending of packets is already tested in SendTimelinePacketTests.
477 std::unique_ptr<armnn::profiling::ISendTimelinePacket> timelinePacket =
478 backendProfilingIface->GetSendTimelinePacket();
479 // Send TimelineEntityClassBinaryPacket
480 const uint64_t entityBinaryPacketProfilingGuid = 123456u;
481 timelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid);
482 timelinePacket->Commit();
483
484 // Reset the profiling servie after the test.
485 options.m_ProfilingOptions.m_EnableProfiling = false;
486 profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
487 }
488
BOOST_AUTO_TEST_CASE(GetProfilingGuidGenerator)489 BOOST_AUTO_TEST_CASE(GetProfilingGuidGenerator)
490 {
491 // Reset the profiling service to the uninitialized state
492 armnn::IRuntime::CreationOptions options;
493 options.m_ProfilingOptions.m_EnableProfiling = true;
494
495 armnn::MockBackendInitialiser initialiser;
496 // Create a runtime. During this the mock backend will be registered and context returned.
497 armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
498 armnn::MockBackendProfilingService mockProfilingService = armnn::MockBackendProfilingService::Instance();
499 armnn::MockBackendProfilingContext *mockBackEndProfilingContext = mockProfilingService.GetContext();
500 // Check that there is a valid context set.
501 BOOST_CHECK(mockBackEndProfilingContext);
502 armnn::IBackendInternal::IBackendProfilingPtr& backendProfilingIface =
503 mockBackEndProfilingContext->GetBackendProfiling();
504 BOOST_CHECK(backendProfilingIface);
505
506 // Get the Guid generator and check the getting two Guid's results in the second being greater than the first.
507 armnn::profiling::IProfilingGuidGenerator& guidGenerator = backendProfilingIface->GetProfilingGuidGenerator();
508 const armnn::profiling::ProfilingDynamicGuid& firstGuid = guidGenerator.NextGuid();
509 const armnn::profiling::ProfilingDynamicGuid& secondGuid = guidGenerator.NextGuid();
510 BOOST_CHECK(secondGuid > firstGuid);
511
512 // Reset the profiling servie after the test.
513 options.m_ProfilingOptions.m_EnableProfiling = false;
514 }
515
516 BOOST_AUTO_TEST_SUITE_END()
517