1 // 2 // Copyright © 2019 Arm Ltd and Contributors. All rights reserved. 3 // SPDX-License-Identifier: MIT 4 // 5 6 #include "ProfilingMocks.hpp" 7 #include "ProfilingTestUtils.hpp" 8 #include "ProfilingOptionsConverter.hpp" 9 #include <Runtime.hpp> 10 #include <ArmNNProfilingServiceInitialiser.hpp> 11 12 #include <armnn/profiling/ArmNNProfiling.hpp> 13 14 #include <client/src/BufferManager.hpp> 15 #include <client/src/ProfilingService.hpp> 16 #include <client/src/ProfilingUtils.hpp> 17 #include <client/src/SendTimelinePacket.hpp> 18 #include <client/src/TimelinePacketWriterFactory.hpp> 19 20 #include <common/include/LabelsAndEventClasses.hpp> 21 #include <common/include/SwTrace.hpp> 22 #include <common/include/Threads.hpp> 23 24 #include <doctest/doctest.h> 25 26 #include <functional> 27 28 using namespace arm::pipe; 29 30 TEST_SUITE("SendTimelinePacketTests") 31 { 32 TEST_CASE("SendTimelineMessageDirectoryPackageTest") 33 { 34 MockBufferManager mockBuffer(512); 35 TimelinePacketWriterFactory timelinePacketWriterFactory(mockBuffer); 36 std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket(); 37 38 sendTimelinePacket->SendTimelineMessageDirectoryPackage(); 39 40 // Get the readable buffer 41 auto packetBuffer = mockBuffer.GetReadableBuffer(); 42 43 unsigned int uint8_t_size = sizeof(uint8_t); 44 unsigned int uint32_t_size = sizeof(uint32_t); 45 unsigned int uint64_t_size = sizeof(uint64_t); 46 47 // Check the packet header 48 unsigned int offset = 0; 49 uint32_t packetHeaderWord0 = ReadUint32(packetBuffer, offset); 50 uint32_t packetFamily = (packetHeaderWord0 >> 26) & 0x0000003F; 51 uint32_t packetClass = (packetHeaderWord0 >> 19) & 0x0000007F; 52 uint32_t packetType = (packetHeaderWord0 >> 16) & 0x00000007; 53 uint32_t streamId = (packetHeaderWord0 >> 0) & 0x00000007; 54 55 CHECK(packetFamily == 1); 56 CHECK(packetClass == 0); 57 CHECK(packetType == 0); 58 CHECK(streamId == 0); 59 60 offset += uint32_t_size; 61 uint32_t packetHeaderWord1 = ReadUint32(packetBuffer, offset); 62 uint32_t sequenceNumbered = (packetHeaderWord1 >> 24) & 0x00000001; 63 uint32_t dataLength = (packetHeaderWord1 >> 0) & 0x00FFFFFF; 64 CHECK(sequenceNumbered == 0); 65 CHECK(dataLength == 443); 66 67 offset += uint32_t_size; 68 uint8_t readStreamVersion = ReadUint8(packetBuffer, offset); 69 CHECK(readStreamVersion == 4); 70 offset += uint8_t_size; 71 uint8_t readPointerBytes = ReadUint8(packetBuffer, offset); 72 CHECK(readPointerBytes == uint64_t_size); 73 offset += uint8_t_size; 74 uint8_t readThreadIdBytes = ReadUint8(packetBuffer, offset); 75 CHECK(readThreadIdBytes == ThreadIdSize); 76 77 offset += uint8_t_size; 78 uint32_t DeclCount = ReadUint32(packetBuffer, offset); 79 CHECK(DeclCount == 5); 80 81 offset += uint32_t_size; 82 arm::pipe::SwTraceMessage swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(), 83 offset, 84 packetBuffer->GetSize()); 85 86 CHECK(swTraceMessage.m_Id == 0); 87 CHECK(swTraceMessage.m_Name == "declareLabel"); 88 CHECK(swTraceMessage.m_UiName == "declare label"); 89 CHECK(swTraceMessage.m_ArgTypes.size() == 2); 90 CHECK(swTraceMessage.m_ArgTypes[0] == 'p'); 91 CHECK(swTraceMessage.m_ArgTypes[1] == 's'); 92 CHECK(swTraceMessage.m_ArgNames.size() == 2); 93 CHECK(swTraceMessage.m_ArgNames[0] == "guid"); 94 CHECK(swTraceMessage.m_ArgNames[1] == "value"); 95 96 swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(), 97 offset, 98 packetBuffer->GetSize()); 99 100 CHECK(swTraceMessage.m_Id == 1); 101 CHECK(swTraceMessage.m_Name == "declareEntity"); 102 CHECK(swTraceMessage.m_UiName == "declare entity"); 103 CHECK(swTraceMessage.m_ArgTypes.size() == 1); 104 CHECK(swTraceMessage.m_ArgTypes[0] == 'p'); 105 CHECK(swTraceMessage.m_ArgNames.size() == 1); 106 CHECK(swTraceMessage.m_ArgNames[0] == "guid"); 107 108 swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(), 109 offset, 110 packetBuffer->GetSize()); 111 112 CHECK(swTraceMessage.m_Id == 2); 113 CHECK(swTraceMessage.m_Name == "declareEventClass"); 114 CHECK(swTraceMessage.m_UiName == "declare event class"); 115 CHECK(swTraceMessage.m_ArgTypes.size() == 2); 116 CHECK(swTraceMessage.m_ArgTypes[0] == 'p'); 117 CHECK(swTraceMessage.m_ArgTypes[1] == 'p'); 118 CHECK(swTraceMessage.m_ArgNames.size() == 2); 119 CHECK(swTraceMessage.m_ArgNames[0] == "guid"); 120 CHECK(swTraceMessage.m_ArgNames[1] == "nameGuid"); 121 122 swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(), 123 offset, 124 packetBuffer->GetSize()); 125 126 CHECK(swTraceMessage.m_Id == 3); 127 CHECK(swTraceMessage.m_Name == "declareRelationship"); 128 CHECK(swTraceMessage.m_UiName == "declare relationship"); 129 CHECK(swTraceMessage.m_ArgTypes.size() == 5); 130 CHECK(swTraceMessage.m_ArgTypes[0] == 'I'); 131 CHECK(swTraceMessage.m_ArgTypes[1] == 'p'); 132 CHECK(swTraceMessage.m_ArgTypes[2] == 'p'); 133 CHECK(swTraceMessage.m_ArgTypes[3] == 'p'); 134 CHECK(swTraceMessage.m_ArgTypes[4] == 'p'); 135 CHECK(swTraceMessage.m_ArgNames.size() == 5); 136 CHECK(swTraceMessage.m_ArgNames[0] == "relationshipType"); 137 CHECK(swTraceMessage.m_ArgNames[1] == "relationshipGuid"); 138 CHECK(swTraceMessage.m_ArgNames[2] == "headGuid"); 139 CHECK(swTraceMessage.m_ArgNames[3] == "tailGuid"); 140 CHECK(swTraceMessage.m_ArgNames[4] == "attributeGuid"); 141 142 swTraceMessage = arm::pipe::ReadSwTraceMessage(packetBuffer->GetReadableData(), 143 offset, 144 packetBuffer->GetSize()); 145 146 CHECK(swTraceMessage.m_Id == 4); 147 CHECK(swTraceMessage.m_Name == "declareEvent"); 148 CHECK(swTraceMessage.m_UiName == "declare event"); 149 CHECK(swTraceMessage.m_ArgTypes.size() == 3); 150 CHECK(swTraceMessage.m_ArgTypes[0] == '@'); 151 CHECK(swTraceMessage.m_ArgTypes[1] == 't'); 152 CHECK(swTraceMessage.m_ArgTypes[2] == 'p'); 153 CHECK(swTraceMessage.m_ArgNames.size() == 3); 154 CHECK(swTraceMessage.m_ArgNames[0] == "timestamp"); 155 CHECK(swTraceMessage.m_ArgNames[1] == "threadId"); 156 CHECK(swTraceMessage.m_ArgNames[2] == "eventGuid"); 157 } 158 159 TEST_CASE("SendTimelineEntityWithEventClassPacketTest") 160 { 161 MockBufferManager bufferManager(40); 162 TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager); 163 std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket(); 164 165 const uint64_t entityBinaryPacketProfilingGuid = 123456u; 166 sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid); 167 168 const uint64_t eventClassBinaryPacketProfilingGuid = 789123u; 169 const uint64_t eventClassBinaryPacketNameGuid = 8845u; 170 sendTimelinePacket->SendTimelineEventClassBinaryPacket( 171 eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid); 172 173 // Commit the messages 174 sendTimelinePacket->Commit(); 175 176 // Get the readable buffer 177 auto packetBuffer = bufferManager.GetReadableBuffer(); 178 179 unsigned int uint32_t_size = sizeof(uint32_t); 180 unsigned int uint64_t_size = sizeof(uint64_t); 181 182 // Check the packet header 183 unsigned int offset = 0; 184 185 // Reading TimelineEntityClassBinaryPacket 186 uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset); 187 uint32_t entityBinaryPacketFamily = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F; 188 uint32_t entityBinaryPacketClass = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F; 189 uint32_t entityBinaryPacketType = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007; 190 uint32_t entityBinaryPacketStreamId = (entityBinaryPacketHeaderWord0 >> 0) & 0x00000007; 191 192 CHECK(entityBinaryPacketFamily == 1); 193 CHECK(entityBinaryPacketClass == 0); 194 CHECK(entityBinaryPacketType == 1); 195 CHECK(entityBinaryPacketStreamId == 0); 196 197 offset += uint32_t_size; 198 199 uint32_t entityBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset); 200 201 uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001; 202 uint32_t entityBinaryPacketDataLength = (entityBinaryPacketHeaderWord1 >> 0) & 0x00FFFFFF; 203 204 CHECK(entityBinaryPacketSequenceNumbered == 0); 205 CHECK(entityBinaryPacketDataLength == 32); 206 207 // Check the decl_id 208 offset += uint32_t_size; 209 uint32_t entitytDecId = ReadUint32(packetBuffer, offset); 210 211 CHECK(entitytDecId == uint32_t(1)); 212 213 // Check the profiling GUID 214 offset += uint32_t_size; 215 uint64_t readProfilingGuid = ReadUint64(packetBuffer, offset); 216 217 CHECK(readProfilingGuid == entityBinaryPacketProfilingGuid); 218 219 // Reading TimelineEventClassBinaryPacket 220 offset += uint64_t_size; 221 222 uint32_t eventClassDeclId = ReadUint32(packetBuffer, offset); 223 CHECK(eventClassDeclId == uint32_t(2)); 224 225 // Check the profiling GUID 226 offset += uint32_t_size; 227 readProfilingGuid = ReadUint64(packetBuffer, offset); 228 CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid); 229 230 offset += uint64_t_size; 231 uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset); 232 CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid); 233 234 bufferManager.MarkRead(packetBuffer); 235 } 236 237 TEST_CASE("SendEventClassAfterTimelineEntityPacketTest") 238 { 239 unsigned int uint32_t_size = sizeof(uint32_t); 240 unsigned int uint64_t_size = sizeof(uint64_t); 241 242 MockBufferManager bufferManager(512); 243 TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager); 244 std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket(); 245 246 // Send TimelineEntityClassBinaryPacket 247 const uint64_t entityBinaryPacketProfilingGuid = 123456u; 248 sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid); 249 250 // Commit the buffer 251 sendTimelinePacket->Commit(); 252 253 // Get the readable buffer 254 auto packetBuffer = bufferManager.GetReadableBuffer(); 255 256 // Check the packet header 257 unsigned int offset = 0; 258 259 // Reading TimelineEntityClassBinaryPacket 260 uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset); 261 uint32_t entityBinaryPacketFamily = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F; 262 uint32_t entityBinaryPacketClass = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F; 263 uint32_t entityBinaryPacketType = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007; 264 uint32_t entityBinaryPacketStreamId = (entityBinaryPacketHeaderWord0 >> 0) & 0x00000007; 265 266 CHECK(entityBinaryPacketFamily == 1); 267 CHECK(entityBinaryPacketClass == 0); 268 CHECK(entityBinaryPacketType == 1); 269 CHECK(entityBinaryPacketStreamId == 0); 270 271 offset += uint32_t_size; 272 uint32_t entityBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset); 273 uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001; 274 uint32_t entityBinaryPacketDataLength = (entityBinaryPacketHeaderWord1 >> 0) & 0x00FFFFFF; 275 CHECK(entityBinaryPacketSequenceNumbered == 0); 276 CHECK(entityBinaryPacketDataLength == 12); 277 278 // Check the decl_id 279 offset += uint32_t_size; 280 uint32_t entitytDecId = ReadUint32(packetBuffer, offset); 281 282 CHECK(entitytDecId == uint32_t(1)); 283 284 // Check the profiling GUID 285 offset += uint32_t_size; 286 uint64_t readProfilingGuid = ReadUint64(packetBuffer, offset); 287 288 CHECK(readProfilingGuid == entityBinaryPacketProfilingGuid); 289 290 bufferManager.MarkRead(packetBuffer); 291 292 // Send TimelineEventClassBinaryPacket 293 const uint64_t eventClassBinaryPacketProfilingGuid = 789123u; 294 const uint64_t eventClassBinaryPacketNameGuid = 8845u; 295 sendTimelinePacket->SendTimelineEventClassBinaryPacket( 296 eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid); 297 298 // Commit the buffer 299 sendTimelinePacket->Commit(); 300 301 // Get the readable buffer 302 packetBuffer = bufferManager.GetReadableBuffer(); 303 304 // Check the packet header 305 offset = 0; 306 307 // Reading TimelineEventClassBinaryPacket 308 uint32_t eventClassBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset); 309 uint32_t eventClassBinaryPacketFamily = (eventClassBinaryPacketHeaderWord0 >> 26) & 0x0000003F; 310 uint32_t eventClassBinaryPacketClass = (eventClassBinaryPacketHeaderWord0 >> 19) & 0x0000007F; 311 uint32_t eventClassBinaryPacketType = (eventClassBinaryPacketHeaderWord0 >> 16) & 0x00000007; 312 uint32_t eventClassBinaryPacketStreamId = (eventClassBinaryPacketHeaderWord0 >> 0) & 0x00000007; 313 314 CHECK(eventClassBinaryPacketFamily == 1); 315 CHECK(eventClassBinaryPacketClass == 0); 316 CHECK(eventClassBinaryPacketType == 1); 317 CHECK(eventClassBinaryPacketStreamId == 0); 318 319 offset += uint32_t_size; 320 uint32_t eventClassBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset); 321 uint32_t eventClassBinaryPacketSequenceNumbered = (eventClassBinaryPacketHeaderWord1 >> 24) & 0x00000001; 322 uint32_t eventClassBinaryPacketDataLength = (eventClassBinaryPacketHeaderWord1 >> 0) & 0x00FFFFFF; 323 CHECK(eventClassBinaryPacketSequenceNumbered == 0); 324 CHECK(eventClassBinaryPacketDataLength == 20); 325 326 offset += uint32_t_size; 327 uint32_t eventClassDeclId = ReadUint32(packetBuffer, offset); 328 CHECK(eventClassDeclId == uint32_t(2)); 329 330 // Check the profiling GUID 331 offset += uint32_t_size; 332 readProfilingGuid = ReadUint64(packetBuffer, offset); 333 CHECK(readProfilingGuid == eventClassBinaryPacketProfilingGuid); 334 335 offset += uint64_t_size; 336 uint64_t readEventClassNameGuid = ReadUint64(packetBuffer, offset); 337 CHECK(readEventClassNameGuid == eventClassBinaryPacketNameGuid); 338 339 bufferManager.MarkRead(packetBuffer); 340 341 // Send TimelineEventBinaryPacket 342 const uint64_t timestamp = 456789u; 343 const int threadId = arm::pipe::GetCurrentThreadId(); 344 const uint64_t eventProfilingGuid = 123456u; 345 sendTimelinePacket->SendTimelineEventBinaryPacket(timestamp, threadId, eventProfilingGuid); 346 347 // Commit the buffer 348 sendTimelinePacket->Commit(); 349 350 // Get the readable buffer 351 packetBuffer = bufferManager.GetReadableBuffer(); 352 353 // Check the packet header 354 offset = 0; 355 356 // Reading TimelineEventBinaryPacket 357 uint32_t eventBinaryPacketHeaderWord0 = ReadUint32(packetBuffer, offset); 358 uint32_t eventBinaryPacketFamily = (eventBinaryPacketHeaderWord0 >> 26) & 0x0000003F; 359 uint32_t eventBinaryPacketClass = (eventBinaryPacketHeaderWord0 >> 19) & 0x0000007F; 360 uint32_t eventBinaryPacketType = (eventBinaryPacketHeaderWord0 >> 16) & 0x00000007; 361 uint32_t eventBinaryPacketStreamId = (eventBinaryPacketHeaderWord0 >> 0) & 0x00000007; 362 363 CHECK(eventBinaryPacketFamily == 1); 364 CHECK(eventBinaryPacketClass == 0); 365 CHECK(eventBinaryPacketType == 1); 366 CHECK(eventBinaryPacketStreamId == 0); 367 368 offset += uint32_t_size; 369 uint32_t eventBinaryPacketHeaderWord1 = ReadUint32(packetBuffer, offset); 370 uint32_t eventBinaryPacketSequenceNumbered = (eventBinaryPacketHeaderWord1 >> 24) & 0x00000001; 371 uint32_t eventBinaryPacketDataLength = (eventBinaryPacketHeaderWord1 >> 0) & 0x00FFFFFF; 372 CHECK(eventBinaryPacketSequenceNumbered == 0); 373 CHECK(eventBinaryPacketDataLength == 20 + ThreadIdSize); 374 375 // Check the decl_id 376 offset += uint32_t_size; 377 uint32_t eventDeclId = ReadUint32(packetBuffer, offset); 378 CHECK(eventDeclId == 4); 379 380 // Check the timestamp 381 offset += uint32_t_size; 382 uint64_t eventTimestamp = ReadUint64(packetBuffer, offset); 383 CHECK(eventTimestamp == timestamp); 384 385 // Check the thread id 386 offset += uint64_t_size; 387 std::vector<uint8_t> readThreadId(ThreadIdSize, 0); 388 ReadBytes(packetBuffer, offset, ThreadIdSize, readThreadId.data()); 389 CHECK(readThreadId == threadId); 390 391 // Check the profiling GUID 392 offset += ThreadIdSize; 393 readProfilingGuid = ReadUint64(packetBuffer, offset); 394 CHECK(readProfilingGuid == eventProfilingGuid); 395 } 396 397 TEST_CASE("SendTimelinePacketTests2") 398 { 399 MockBufferManager bufferManager(40); 400 TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager); 401 std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket(); 402 403 CHECK_THROWS_AS(sendTimelinePacket->SendTimelineMessageDirectoryPackage(), 404 arm::pipe::ProfilingException); 405 } 406 407 TEST_CASE("SendTimelinePacketTests3") 408 { 409 MockBufferManager bufferManager(512); 410 TimelinePacketWriterFactory timelinePacketWriterFactory(bufferManager); 411 std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = timelinePacketWriterFactory.GetSendTimelinePacket(); 412 413 // Send TimelineEntityClassBinaryPacket 414 const uint64_t entityBinaryPacketProfilingGuid = 123456u; 415 sendTimelinePacket->SendTimelineEntityBinaryPacket(entityBinaryPacketProfilingGuid); 416 417 // Commit the buffer 418 sendTimelinePacket->Commit(); 419 420 // Get the readable buffer 421 auto packetBuffer = bufferManager.GetReadableBuffer(); 422 423 // Send TimelineEventClassBinaryPacket 424 const uint64_t eventClassBinaryPacketProfilingGuid = 789123u; 425 const uint64_t eventClassBinaryPacketNameGuid = 8845u; 426 CHECK_THROWS_AS(sendTimelinePacket->SendTimelineEventClassBinaryPacket( 427 eventClassBinaryPacketProfilingGuid, eventClassBinaryPacketNameGuid), 428 BufferExhaustion); 429 } 430 431 TEST_CASE("GetGuidsFromProfilingService") 432 { 433 LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal); 434 435 armnn::IRuntime::CreationOptions options; 436 options.m_ProfilingOptions.m_EnableProfiling = true; 437 armnn::RuntimeImpl runtime(options); 438 armnn::ArmNNProfilingServiceInitialiser initialiser; 439 ProfilingService profilingService(arm::pipe::MAX_ARMNN_COUNTER, 440 initialiser, 441 arm::pipe::ARMNN_SOFTWARE_INFO, 442 arm::pipe::ARMNN_SOFTWARE_VERSION, 443 arm::pipe::ARMNN_HARDWARE_VERSION, 444 runtime); 445 446 profilingService.ResetExternalProfilingOptions( 447 ConvertExternalProfilingOptions(options.m_ProfilingOptions), true); 448 ProfilingStaticGuid staticGuid = profilingService.GetStaticId("dummy"); 449 std::hash<std::string> hasher; 450 uint64_t hash = static_cast<uint64_t>(hasher("dummy")); 451 ProfilingStaticGuid expectedStaticValue(hash | MIN_STATIC_GUID); 452 CHECK(staticGuid == expectedStaticValue); 453 ProfilingDynamicGuid dynamicGuid = profilingService.GetNextGuid(); 454 uint64_t dynamicGuidValue = static_cast<uint64_t>(dynamicGuid); 455 ++dynamicGuidValue; 456 ProfilingDynamicGuid expectedDynamicValue(dynamicGuidValue); 457 dynamicGuid = profilingService.GetNextGuid(); 458 CHECK(dynamicGuid == expectedDynamicValue); 459 } 460 461 TEST_CASE("GetTimelinePackerWriterFromProfilingService") 462 { 463 LogLevelSwapper logLevelSwapper(arm::pipe::LogSeverity::Fatal); 464 465 ProfilingOptions options; 466 options.m_EnableProfiling = true; 467 armnn::ArmNNProfilingServiceInitialiser initialiser; 468 ProfilingService profilingService(arm::pipe::MAX_ARMNN_COUNTER, 469 initialiser, 470 arm::pipe::ARMNN_SOFTWARE_INFO, 471 arm::pipe::ARMNN_SOFTWARE_VERSION, 472 arm::pipe::ARMNN_HARDWARE_VERSION); 473 profilingService.ResetExternalProfilingOptions(options, true); 474 475 std::unique_ptr<ISendTimelinePacket> writer = profilingService.GetSendTimelinePacket(); 476 CHECK(writer != nullptr); 477 } 478 479 TEST_CASE("CheckStaticGuidsAndEvents") 480 { 481 CHECK("name" == LabelsAndEventClasses::NAME_LABEL); 482 CHECK("type" == LabelsAndEventClasses::TYPE_LABEL); 483 CHECK("index" == LabelsAndEventClasses::INDEX_LABEL); 484 485 std::hash<std::string> hasher; 486 487 uint64_t hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::NAME_LABEL)); 488 ProfilingStaticGuid expectedNameGuid(hash | MIN_STATIC_GUID); 489 CHECK(LabelsAndEventClasses::NAME_GUID == expectedNameGuid); 490 491 hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::TYPE_LABEL)); 492 ProfilingStaticGuid expectedTypeGuid(hash | MIN_STATIC_GUID); 493 CHECK(LabelsAndEventClasses::TYPE_GUID == expectedTypeGuid); 494 495 hash = static_cast<uint64_t>(hasher(LabelsAndEventClasses::INDEX_LABEL)); 496 ProfilingStaticGuid expectedIndexGuid(hash | MIN_STATIC_GUID); 497 CHECK(LabelsAndEventClasses::INDEX_GUID == expectedIndexGuid); 498 499 hash = static_cast<uint64_t>(hasher("ARMNN_PROFILING_SOL")); 500 ProfilingStaticGuid expectedSol(hash | MIN_STATIC_GUID); 501 CHECK(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS == expectedSol); 502 503 hash = static_cast<uint64_t>(hasher("ARMNN_PROFILING_EOL")); 504 ProfilingStaticGuid expectedEol(hash | MIN_STATIC_GUID); 505 CHECK(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS == expectedEol); 506 } 507 508 } 509