src/profiling/test/ProfilingTestUtils.cpp

   1 //
   2 // Copyright © 2019 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include "ProfilingTestUtils.hpp"
   7 #include "ProfilingUtils.hpp"
   8
   9 #include <armnn/Descriptors.hpp>
  10 #include <LabelsAndEventClasses.hpp>
  11 #include <ProfilingService.hpp>
  12 #include <Runtime.hpp>
  13
  14 #include <boost/test/unit_test.hpp>
  15
  16 inline unsigned int OffsetToNextWord(unsigned int numberOfBytes)
  17 {
  18     unsigned int uint32_t_size = sizeof(uint32_t);
  19
  20     unsigned int remainder = numberOfBytes % uint32_t_size;
  21     if (remainder == 0)
  22     {
  23         return numberOfBytes;
  24     }
  25
  26     return numberOfBytes + uint32_t_size - remainder;
  27 }
  28
  29 void VerifyTimelineHeaderBinary(const unsigned char* readableData,
  30                                 unsigned int& offset,
  31                                 uint32_t packetDataLength)
  32 {
  33     BOOST_ASSERT(readableData);
  34
  35     // Utils
  36     unsigned int uint32_t_size = sizeof(uint32_t);
  37
  38     // Check the TimelineEventClassBinaryPacket header
  39     uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
  40     uint32_t entityBinaryPacketFamily      = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
  41     uint32_t entityBinaryPacketClass       = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
  42     uint32_t entityBinaryPacketType        = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
  43     uint32_t entityBinaryPacketStreamId    = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;
  44     BOOST_CHECK(entityBinaryPacketFamily   == 1);
  45     BOOST_CHECK(entityBinaryPacketClass    == 0);
  46     BOOST_CHECK(entityBinaryPacketType     == 1);
  47     BOOST_CHECK(entityBinaryPacketStreamId == 0);
  48     offset += uint32_t_size;
  49     uint32_t entityBinaryPacketHeaderWord1   = ReadUint32(readableData, offset);
  50     uint32_t eventBinaryPacketSequenceNumber = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
  51     uint32_t eventBinaryPacketDataLength     = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
  52     BOOST_CHECK(eventBinaryPacketSequenceNumber == 0);
  53     BOOST_CHECK(eventBinaryPacketDataLength     == packetDataLength);
  54     offset += uint32_t_size;
  55 }
  56
  57 void VerifyTimelineLabelBinaryPacketData(Optional<ProfilingGuid> guid,
  58                                          const std::string& label,
  59                                          const unsigned char* readableData,
  60                                          unsigned int& offset)
  61 {
  62     BOOST_ASSERT(readableData);
  63
  64     // Utils
  65     unsigned int uint32_t_size = sizeof(uint32_t);
  66     unsigned int uint64_t_size = sizeof(uint64_t);
  67     unsigned int label_size    = boost::numeric_cast<unsigned int>(label.size());
  68
  69     // Check the decl id
  70     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
  71     BOOST_CHECK(eventClassDeclId == 0);
  72
  73     // Check the profiling GUID
  74     offset += uint32_t_size;
  75     uint64_t readProfilingGuid = ReadUint64(readableData, offset);
  76     if (guid.has_value())
  77     {
  78         BOOST_CHECK(readProfilingGuid == guid.value());
  79     }
  80     else
  81     {
  82         armnn::profiling::ProfilingService profilingService;
  83         BOOST_CHECK(readProfilingGuid == profilingService.GetStaticId(label));
  84     }
  85
  86     // Check the SWTrace label
  87     offset += uint64_t_size;
  88     uint32_t swTraceLabelLength = ReadUint32(readableData, offset);
  89     BOOST_CHECK(swTraceLabelLength == label_size + 1);               // Label length including the null-terminator
  90     offset += uint32_t_size;
  91     BOOST_CHECK(std::memcmp(readableData + offset,                  // Offset to the label in the buffer
  92                                label.data(),                           // The original label
  93                                swTraceLabelLength - 1) == 0);          // The length of the label
  94
  95     // SWTrace strings are written in blocks of words, so the offset has to be updated to the next whole word
  96     offset += OffsetToNextWord(swTraceLabelLength);
  97 }
  98
  99 void VerifyTimelineEventClassBinaryPacketData(ProfilingGuid guid,
 100                                               const unsigned char* readableData,
 101                                               unsigned int& offset)
 102 {
 103     BOOST_ASSERT(readableData);
 104
 105     // Utils
 106     unsigned int uint32_t_size = sizeof(uint32_t);
 107     unsigned int uint64_t_size = sizeof(uint64_t);
 108
 109     // Check the decl id
 110     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
 111     BOOST_CHECK(eventClassDeclId == 2);
 112
 113     // Check the profiling GUID
 114     offset += uint32_t_size;
 115     uint64_t readProfilingGuid = ReadUint64(readableData, offset);
 116     BOOST_CHECK(readProfilingGuid == guid);
 117
 118     // Update the offset to allow parsing to be continued after this function returns
 119     offset += uint64_t_size;
 120 }
 121
 122 void VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType relationshipType,
 123                                             Optional<ProfilingGuid> relationshipGuid,
 124                                             Optional<ProfilingGuid> headGuid,
 125                                             Optional<ProfilingGuid> tailGuid,
 126                                             const unsigned char* readableData,
 127                                             unsigned int& offset)
 128 {
 129     BOOST_ASSERT(readableData);
 130
 131     uint32_t relationshipTypeUint = 0;
 132     switch (relationshipType)
 133     {
 134         case ProfilingRelationshipType::RetentionLink:
 135             relationshipTypeUint = 0;
 136             break;
 137         case ProfilingRelationshipType::ExecutionLink:
 138             relationshipTypeUint = 1;
 139             break;
 140         case ProfilingRelationshipType::DataLink:
 141             relationshipTypeUint = 2;
 142             break;
 143         case ProfilingRelationshipType::LabelLink:
 144             relationshipTypeUint = 3;
 145             break;
 146         default:
 147             BOOST_ERROR("Unknown relationship type");
 148     }
 149
 150     // Utils
 151     unsigned int uint32_t_size = sizeof(uint32_t);
 152     unsigned int uint64_t_size = sizeof(uint64_t);
 153
 154     // Check the decl id
 155     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
 156     BOOST_CHECK(eventClassDeclId == 3);
 157
 158     // Check the relationship type
 159     offset += uint32_t_size;
 160     uint32_t readRelationshipTypeUint = ReadUint32(readableData, offset);
 161     BOOST_CHECK(readRelationshipTypeUint == relationshipTypeUint);
 162
 163     // Check the relationship GUID
 164     offset += uint32_t_size;
 165     uint64_t readRelationshipGuid = ReadUint64(readableData, offset);
 166     if (relationshipGuid.has_value())
 167     {
 168         BOOST_CHECK(readRelationshipGuid == relationshipGuid.value());
 169     }
 170     else
 171     {
 172         BOOST_CHECK(readRelationshipGuid != ProfilingGuid(0));
 173     }
 174
 175     // Check the head of relationship GUID
 176     offset += uint64_t_size;
 177     uint64_t readHeadRelationshipGuid = ReadUint64(readableData, offset);
 178     if (headGuid.has_value())
 179     {
 180         BOOST_CHECK(readHeadRelationshipGuid == headGuid.value());
 181     }
 182     else
 183     {
 184         BOOST_CHECK(readHeadRelationshipGuid != ProfilingGuid(0));
 185     }
 186
 187     // Check the tail of relationship GUID
 188     offset += uint64_t_size;
 189     uint64_t readTailRelationshipGuid = ReadUint64(readableData, offset);
 190     if (tailGuid.has_value())
 191     {
 192         BOOST_CHECK(readTailRelationshipGuid == tailGuid.value());
 193     }
 194     else
 195     {
 196         BOOST_CHECK(readTailRelationshipGuid != ProfilingGuid(0));
 197     }
 198
 199     // Update the offset to allow parsing to be continued after this function returns
 200     offset += uint64_t_size;
 201 }
 202
 203 void VerifyTimelineEntityBinaryPacketData(Optional<ProfilingGuid> guid,
 204                                           const unsigned char* readableData,
 205                                           unsigned int& offset)
 206 {
 207     BOOST_ASSERT(readableData);
 208
 209     // Utils
 210     unsigned int uint32_t_size = sizeof(uint32_t);
 211     unsigned int uint64_t_size = sizeof(uint64_t);
 212
 213     // Reading TimelineEntityClassBinaryPacket
 214     // Check the decl_id
 215     uint32_t entityDeclId = ReadUint32(readableData, offset);
 216     BOOST_CHECK(entityDeclId == 1);
 217
 218     // Check the profiling GUID
 219     offset += uint32_t_size;
 220     uint64_t readProfilingGuid = ReadUint64(readableData, offset);
 221
 222     if (guid.has_value())
 223     {
 224         BOOST_CHECK(readProfilingGuid == guid.value());
 225     }
 226     else
 227     {
 228         BOOST_CHECK(readProfilingGuid != ProfilingGuid(0));
 229     }
 230
 231     offset += uint64_t_size;
 232 }
 233
 234 void VerifyTimelineEventBinaryPacket(Optional<uint64_t> timestamp,
 235                                      Optional<std::thread::id> threadId,
 236                                      Optional<ProfilingGuid> eventGuid,
 237                                      const unsigned char* readableData,
 238                                      unsigned int& offset)
 239 {
 240     BOOST_ASSERT(readableData);
 241
 242     // Utils
 243     unsigned int uint32_t_size = sizeof(uint32_t);
 244     unsigned int uint64_t_size = sizeof(uint64_t);
 245     unsigned int threadId_size = sizeof(std::thread::id);
 246
 247     // Reading TimelineEventBinaryPacket
 248     // Check the decl_id
 249     uint32_t entityDeclId = ReadUint32(readableData, offset);
 250     BOOST_CHECK(entityDeclId == 4);
 251
 252     // Check the timestamp
 253     offset += uint32_t_size;
 254     uint64_t readTimestamp = ReadUint64(readableData, offset);
 255     if (timestamp.has_value())
 256     {
 257         BOOST_CHECK(readTimestamp == timestamp.value());
 258     }
 259     else
 260     {
 261         BOOST_CHECK(readTimestamp != 0);
 262     }
 263
 264     // Check the thread id
 265     offset += uint64_t_size;
 266     std::vector<uint8_t> readThreadId(threadId_size, 0);
 267     ReadBytes(readableData, offset, threadId_size, readThreadId.data());
 268     if (threadId.has_value())
 269     {
 270         BOOST_CHECK(readThreadId == threadId.value());
 271     }
 272     else
 273     {
 274         BOOST_CHECK(readThreadId == std::this_thread::get_id());
 275     }
 276
 277     // Check the event GUID
 278     offset += threadId_size;
 279     uint64_t readEventGuid = ReadUint64(readableData, offset);
 280     if (eventGuid.has_value())
 281     {
 282         BOOST_CHECK(readEventGuid == eventGuid.value());
 283     }
 284     else
 285     {
 286         BOOST_CHECK(readEventGuid != ProfilingGuid(0));
 287     }
 288
 289     offset += uint64_t_size;
 290 }
 291
 292 void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
 293 {
 294     using namespace armnn;
 295
 296     // Create runtime in which test will run
 297     armnn::IRuntime::CreationOptions options;
 298     options.m_ProfilingOptions.m_EnableProfiling = true;
 299 //    armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
 300     armnn::Runtime runtime(options);
 301
 302     // build up the structure of the network
 303     INetworkPtr net(INetwork::Create());
 304
 305     // Convolution details
 306     TensorInfo inputInfo({ 1, 2, 5, 1 }, DataType::Float32);
 307     TensorInfo weightInfo({ 3, 2, 3, 1 }, DataType::Float32);
 308     TensorInfo biasInfo({ 3 }, DataType::Float32);
 309     TensorInfo outputInfo({ 1, 3, 7, 1 }, DataType::Float32);
 310     std::vector<float> weightsData{
 311         1.0f, 0.0f, 0.0f,
 312         0.0f, 2.0f, -1.5f,
 313
 314         0.0f, 0.0f, 0.0f,
 315         0.2f, 0.2f, 0.2f,
 316
 317         0.5f, 0.0f, 0.5f,
 318         0.0f, -1.0f, 0.0f
 319     };
 320     ConstTensor weights(weightInfo, weightsData);
 321
 322     Optional<ConstTensor> optionalBiases;
 323     std::vector<float> biasesData{ 1.0f, 0.0f, 0.0f };
 324     ConstTensor biases(biasInfo, biasesData);
 325     optionalBiases = Optional<ConstTensor>(biases);
 326
 327     // Input layer
 328     IConnectableLayer* input = net->AddInputLayer(0, "input");
 329
 330     // Convolution2d layer
 331     Convolution2dDescriptor conv2dDesc;
 332     conv2dDesc.m_StrideX = 1;
 333     conv2dDesc.m_StrideY = 1;
 334     conv2dDesc.m_PadLeft = 0;
 335     conv2dDesc.m_PadRight = 0;
 336     conv2dDesc.m_PadTop = 2;
 337     conv2dDesc.m_PadBottom = 2;
 338     conv2dDesc.m_BiasEnabled = true;
 339     IConnectableLayer* conv2d = net->AddConvolution2dLayer(conv2dDesc, weights, optionalBiases);
 340
 341     // Activation layer
 342     armnn::ActivationDescriptor activationDesc;
 343     armnn::IConnectableLayer* const activation = net->AddActivationLayer(activationDesc, "activation");
 344
 345     // Output layer
 346     IConnectableLayer* output = net->AddOutputLayer(0, "output");
 347
 348     input->GetOutputSlot(0).Connect(conv2d->GetInputSlot(0));
 349     conv2d->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
 350     activation->GetOutputSlot(0).Connect(output->GetInputSlot(0));
 351
 352     input->GetOutputSlot(0).SetTensorInfo(inputInfo);
 353     conv2d->GetOutputSlot(0).SetTensorInfo(outputInfo);
 354     activation->GetOutputSlot(0).SetTensorInfo(outputInfo);
 355
 356     // optimize the network
 357     std::vector<armnn::BackendId> backends = { backendId };
 358     IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime.GetDeviceSpec());
 359
 360     ProfilingGuid optNetGuid = optNet->GetGuid();
 361
 362     // Load it into the runtime. It should success.
 363     armnn::NetworkId netId;
 364     BOOST_TEST(runtime.LoadNetwork(netId, std::move(optNet)) == Status::Success);
 365
 366     profiling::ProfilingServiceRuntimeHelper profilingServiceHelper(GetProfilingService(&runtime));
 367     profiling::BufferManager& bufferManager = profilingServiceHelper.GetProfilingBufferManager();
 368     auto readableBuffer = bufferManager.GetReadableBuffer();
 369
 370     // Profiling is enable, the post-optimisation structure should be created
 371     BOOST_CHECK(readableBuffer != nullptr);
 372
 373     unsigned int size = readableBuffer->GetSize();
 374     BOOST_CHECK(size == 1556);
 375
 376     const unsigned char* readableData = readableBuffer->GetReadableData();
 377     BOOST_CHECK(readableData != nullptr);
 378
 379     unsigned int offset = 0;
 380
 381     // Verify Header
 382     VerifyTimelineHeaderBinary(readableData, offset, 1548);
 383
 384     // Post-optimisation network
 385     // Network entity
 386     VerifyTimelineEntityBinaryPacketData(optNetGuid, readableData, offset);
 387
 388     // Entity - Type relationship
 389     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 390                                                EmptyOptional(),
 391                                                optNetGuid,
 392                                                EmptyOptional(),
 393                                                readableData,
 394                                                offset);
 395
 396     // Type label relationship
 397     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 398                                                EmptyOptional(),
 399                                                EmptyOptional(),
 400                                                LabelsAndEventClasses::TYPE_GUID,
 401                                                readableData,
 402                                                offset);
 403
 404     // Input layer
 405     // Input layer entity
 406     VerifyTimelineEntityBinaryPacketData(input->GetGuid(), readableData, offset);
 407
 408     // Name Entity
 409     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "input", readableData, offset);
 410
 411     // Entity - Name relationship
 412     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 413                                                EmptyOptional(),
 414                                                input->GetGuid(),
 415                                                EmptyOptional(),
 416                                                readableData,
 417                                                offset);
 418
 419     // Name label relationship
 420     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 421                                                EmptyOptional(),
 422                                                EmptyOptional(),
 423                                                LabelsAndEventClasses::NAME_GUID,
 424                                                readableData,
 425                                                offset);
 426
 427     // Entity - Type relationship
 428     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 429                                                EmptyOptional(),
 430                                                input->GetGuid(),
 431                                                EmptyOptional(),
 432                                                readableData,
 433                                                offset);
 434
 435     // Type label relationship
 436     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 437                                                EmptyOptional(),
 438                                                EmptyOptional(),
 439                                                LabelsAndEventClasses::TYPE_GUID,
 440                                                readableData,
 441                                                offset);
 442
 443     // Network - Input layer relationship
 444     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 445                                                EmptyOptional(),
 446                                                optNetGuid,
 447                                                input->GetGuid(),
 448                                                readableData,
 449                                                offset);
 450
 451     // Conv2d layer
 452     // Conv2d layer entity
 453     VerifyTimelineEntityBinaryPacketData(conv2d->GetGuid(), readableData, offset);
 454
 455     // Name entity
 456     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "<Unnamed>", readableData, offset);
 457
 458     // Entity - Name relationship
 459     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 460                                                EmptyOptional(),
 461                                                conv2d->GetGuid(),
 462                                                EmptyOptional(),
 463                                                readableData,
 464                                                offset);
 465
 466     // Name label relationship
 467     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 468                                                EmptyOptional(),
 469                                                EmptyOptional(),
 470                                                LabelsAndEventClasses::NAME_GUID,
 471                                                readableData,
 472                                                offset);
 473
 474     // Entity - Type relationship
 475     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 476                                                EmptyOptional(),
 477                                                conv2d->GetGuid(),
 478                                                EmptyOptional(),
 479                                                readableData,
 480                                                offset);
 481
 482     // Type label relationship
 483     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 484                                                EmptyOptional(),
 485                                                EmptyOptional(),
 486                                                LabelsAndEventClasses::TYPE_GUID,
 487                                                readableData,
 488                                                offset);
 489
 490     // Network - Conv2d layer relationship
 491     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 492                                                EmptyOptional(),
 493                                                optNetGuid,
 494                                                conv2d->GetGuid(),
 495                                                readableData,
 496                                                offset);
 497
 498     // Input layer - Conv2d layer relationship
 499     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 500                                                EmptyOptional(),
 501                                                input->GetGuid(),
 502                                                conv2d->GetGuid(),
 503                                                readableData,
 504                                                offset);
 505
 506     // Entity - Type relationship
 507     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 508                                                EmptyOptional(),
 509                                                EmptyOptional(),
 510                                                LabelsAndEventClasses::CONNECTION_GUID,
 511                                                readableData,
 512                                                offset);
 513
 514     // Type label relationship
 515     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 516                                                EmptyOptional(),
 517                                                EmptyOptional(),
 518                                                LabelsAndEventClasses::TYPE_GUID,
 519                                                readableData,
 520                                                offset);
 521
 522     // Conv2d workload
 523     // Conv2d workload entity
 524     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 525
 526     // Entity - Type relationship
 527     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 528                                                EmptyOptional(),
 529                                                EmptyOptional(),
 530                                                EmptyOptional(),
 531                                                readableData,
 532                                                offset);
 533
 534     // Type label relationship
 535     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 536                                                EmptyOptional(),
 537                                                EmptyOptional(),
 538                                                LabelsAndEventClasses::TYPE_GUID,
 539                                                readableData,
 540                                                offset);
 541
 542     // BackendId entity
 543     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 544
 545     // Entity - BackendId relationship
 546     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 547                                                EmptyOptional(),
 548                                                EmptyOptional(),
 549                                                EmptyOptional(),
 550                                                readableData,
 551                                                offset);
 552
 553     // BackendId label relationship
 554     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 555                                                EmptyOptional(),
 556                                                EmptyOptional(),
 557                                                LabelsAndEventClasses::BACKENDID_GUID,
 558                                                readableData,
 559                                                offset);
 560
 561     // Conv2d layer - Conv2d workload relationship
 562     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 563                                                EmptyOptional(),
 564                                                conv2d->GetGuid(),
 565                                                EmptyOptional(),
 566                                                readableData,
 567                                                offset);
 568
 569     // Activation layer
 570     // Activation layer entity
 571     VerifyTimelineEntityBinaryPacketData(activation->GetGuid(), readableData, offset);
 572
 573     // Name entity
 574     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "activation", readableData, offset);
 575
 576     // Entity - Name relationship
 577     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 578                                                EmptyOptional(),
 579                                                activation->GetGuid(),
 580                                                EmptyOptional(),
 581                                                readableData,
 582                                                offset);
 583
 584     // Name label relationship
 585     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 586                                                EmptyOptional(),
 587                                                EmptyOptional(),
 588                                                LabelsAndEventClasses::NAME_GUID,
 589                                                readableData,
 590                                                offset);
 591
 592     // Entity - Type relationship
 593     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 594                                                EmptyOptional(),
 595                                                activation->GetGuid(),
 596                                                EmptyOptional(),
 597                                                readableData,
 598                                                offset);
 599
 600     // Type label relationship
 601     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 602                                                EmptyOptional(),
 603                                                EmptyOptional(),
 604                                                LabelsAndEventClasses::TYPE_GUID,
 605                                                readableData,
 606                                                offset);
 607
 608     // Network - Activation layer relationship
 609     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 610                                                EmptyOptional(),
 611                                                optNetGuid,
 612                                                activation->GetGuid(),
 613                                                readableData,
 614                                                offset);
 615
 616     // Conv2d layer - Activation layer relationship
 617     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 618                                                EmptyOptional(),
 619                                                conv2d->GetGuid(),
 620                                                activation->GetGuid(),
 621                                                readableData,
 622                                                offset);
 623
 624     // Entity - Type relationship
 625     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 626                                                EmptyOptional(),
 627                                                EmptyOptional(),
 628                                                LabelsAndEventClasses::CONNECTION_GUID,
 629                                                readableData,
 630                                                offset);
 631
 632     // Type label relationship
 633     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 634                                                EmptyOptional(),
 635                                                EmptyOptional(),
 636                                                LabelsAndEventClasses::TYPE_GUID,
 637                                                readableData,
 638                                                offset);
 639
 640     // Activation workload
 641     // Activation workload entity
 642     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 643
 644     // Entity - Type relationship
 645     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 646                                                EmptyOptional(),
 647                                                EmptyOptional(),
 648                                                EmptyOptional(),
 649                                                readableData,
 650                                                offset);
 651
 652     // Type label relationship
 653     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 654                                                EmptyOptional(),
 655                                                EmptyOptional(),
 656                                                LabelsAndEventClasses::TYPE_GUID,
 657                                                readableData,
 658                                                offset);
 659
 660     // BackendId entity
 661     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 662
 663     // Entity - BackendId relationship
 664     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 665                                                EmptyOptional(),
 666                                                EmptyOptional(),
 667                                                EmptyOptional(),
 668                                                readableData,
 669                                                offset);
 670
 671     // BackendId label relationship
 672     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 673                                                EmptyOptional(),
 674                                                EmptyOptional(),
 675                                                LabelsAndEventClasses::BACKENDID_GUID,
 676                                                readableData,
 677                                                offset);
 678
 679     // Activation layer - Activation workload relationship
 680     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 681                                                EmptyOptional(),
 682                                                activation->GetGuid(),
 683                                                EmptyOptional(),
 684                                                readableData,
 685                                                offset);
 686
 687     // Output layer
 688     // Output layer entity
 689     VerifyTimelineEntityBinaryPacketData(output->GetGuid(), readableData, offset);
 690
 691     // Name entity
 692     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "output", readableData, offset);
 693
 694     // Entity - Name relationship
 695     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 696                                                EmptyOptional(),
 697                                                output->GetGuid(),
 698                                                EmptyOptional(),
 699                                                readableData,
 700                                                offset);
 701
 702     // Name label relationship
 703     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 704                                                EmptyOptional(),
 705                                                EmptyOptional(),
 706                                                LabelsAndEventClasses::NAME_GUID,
 707                                                readableData,
 708                                                offset);
 709
 710     // Entity - Type relationship
 711     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 712                                                EmptyOptional(),
 713                                                output->GetGuid(),
 714                                                EmptyOptional(),
 715                                                readableData,
 716                                                offset);
 717
 718     // Type label relationship
 719     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 720                                                EmptyOptional(),
 721                                                EmptyOptional(),
 722                                                LabelsAndEventClasses::TYPE_GUID,
 723                                                readableData,
 724                                                offset);
 725
 726     // Network - Output layer relationship
 727     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 728                                                EmptyOptional(),
 729                                                optNetGuid,
 730                                                output->GetGuid(),
 731                                                readableData,
 732                                                offset);
 733
 734     // Activation layer - Output layer relationship
 735     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 736                                                EmptyOptional(),
 737                                                activation->GetGuid(),
 738                                                output->GetGuid(),
 739                                                readableData,
 740                                                offset);
 741
 742     // Entity - Type relationship
 743     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 744                                                EmptyOptional(),
 745                                                EmptyOptional(),
 746                                                LabelsAndEventClasses::CONNECTION_GUID,
 747                                                readableData,
 748                                                offset);
 749
 750     // Type label relationship
 751     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 752                                                EmptyOptional(),
 753                                                EmptyOptional(),
 754                                                LabelsAndEventClasses::TYPE_GUID,
 755                                                readableData,
 756                                                offset);
 757
 758     bufferManager.MarkRead(readableBuffer);
 759
 760     // Creates structures for input & output.
 761     std::vector<float> inputData(inputInfo.GetNumElements());
 762     std::vector<float> outputData(outputInfo.GetNumElements());
 763
 764     InputTensors inputTensors
 765         {
 766         {0, ConstTensor(runtime.GetInputTensorInfo(netId, 0), inputData.data())}
 767         };
 768     OutputTensors outputTensors
 769         {
 770         {0, Tensor(runtime.GetOutputTensorInfo(netId, 0), outputData.data())}
 771         };
 772
 773     // Does the inference.
 774     runtime.EnqueueWorkload(netId, inputTensors, outputTensors);
 775
 776     // Get readable buffer for inference timeline
 777     auto inferenceReadableBuffer = bufferManager.GetReadableBuffer();
 778     BOOST_CHECK(inferenceReadableBuffer != nullptr);
 779
 780     // Get readable buffer for output workload
 781     auto outputReadableBuffer = bufferManager.GetReadableBuffer();
 782     BOOST_CHECK(outputReadableBuffer != nullptr);
 783
 784     // Get readable buffer for input workload
 785     auto inputReadableBuffer = bufferManager.GetReadableBuffer();
 786     BOOST_CHECK(inputReadableBuffer != nullptr);
 787
 788     // Validate input workload data
 789     size = inputReadableBuffer->GetSize();
 790     BOOST_CHECK(size == 204);
 791
 792     readableData = inputReadableBuffer->GetReadableData();
 793     BOOST_CHECK(readableData != nullptr);
 794
 795     offset = 0;
 796
 797     // Verify Header
 798     VerifyTimelineHeaderBinary(readableData, offset, 196);
 799
 800     // Input workload
 801     // Input workload entity
 802     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 803
 804     // Entity - Type relationship
 805     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 806                                                EmptyOptional(),
 807                                                EmptyOptional(),
 808                                                EmptyOptional(),
 809                                                readableData,
 810                                                offset);
 811
 812     // Type label relationship
 813     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 814                                                EmptyOptional(),
 815                                                EmptyOptional(),
 816                                                LabelsAndEventClasses::TYPE_GUID,
 817                                                readableData,
 818                                                offset);
 819
 820     // BackendId entity
 821     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 822
 823     // Entity - BackendId relationship
 824     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 825                                                EmptyOptional(),
 826                                                EmptyOptional(),
 827                                                EmptyOptional(),
 828                                                readableData,
 829                                                offset);
 830
 831     // BackendId label relationship
 832     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 833                                                EmptyOptional(),
 834                                                EmptyOptional(),
 835                                                LabelsAndEventClasses::BACKENDID_GUID,
 836                                                readableData,
 837                                                offset);
 838
 839     // Input layer - Input workload relationship
 840     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 841                                                EmptyOptional(),
 842                                                input->GetGuid(),
 843                                                EmptyOptional(),
 844                                                readableData,
 845                                                offset);
 846
 847     bufferManager.MarkRead(inputReadableBuffer);
 848
 849     // Validate output workload data
 850     size = outputReadableBuffer->GetSize();
 851     BOOST_CHECK(size == 204);
 852
 853     readableData = outputReadableBuffer->GetReadableData();
 854     BOOST_CHECK(readableData != nullptr);
 855
 856     offset = 0;
 857
 858     // Verify Header
 859     VerifyTimelineHeaderBinary(readableData, offset, 196);
 860
 861     // Output workload
 862     // Output workload entity
 863     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 864
 865     // Entity - Type relationship
 866     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 867                                                EmptyOptional(),
 868                                                EmptyOptional(),
 869                                                EmptyOptional(),
 870                                                readableData,
 871                                                offset);
 872
 873     // Type label relationship
 874     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 875                                                EmptyOptional(),
 876                                                EmptyOptional(),
 877                                                LabelsAndEventClasses::TYPE_GUID,
 878                                                readableData,
 879                                                offset);
 880
 881     // BackendId entity
 882     VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 883
 884     // Entity - BackendId relationship
 885     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 886                                                EmptyOptional(),
 887                                                EmptyOptional(),
 888                                                EmptyOptional(),
 889                                                readableData,
 890                                                offset);
 891
 892     // BackendId label relationship
 893     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 894                                                EmptyOptional(),
 895                                                EmptyOptional(),
 896                                                LabelsAndEventClasses::BACKENDID_GUID,
 897                                                readableData,
 898                                                offset);
 899
 900     // Output layer - Output workload relationship
 901     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 902                                                EmptyOptional(),
 903                                                output->GetGuid(),
 904                                                EmptyOptional(),
 905                                                readableData,
 906                                                offset);
 907
 908     bufferManager.MarkRead(outputReadableBuffer);
 909
 910     // Validate inference data
 911     size = inferenceReadableBuffer->GetSize();
 912     BOOST_CHECK(size == 1596);
 913
 914     readableData = inferenceReadableBuffer->GetReadableData();
 915     BOOST_CHECK(readableData != nullptr);
 916
 917     offset = 0;
 918
 919     // Verify Header
 920     VerifyTimelineHeaderBinary(readableData, offset, 1588);
 921
 922     // Inference timeline trace
 923     // Inference entity
 924     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 925
 926     // Entity - Type relationship
 927     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 928                                                EmptyOptional(),
 929                                                EmptyOptional(),
 930                                                LabelsAndEventClasses::INFERENCE_GUID,
 931                                                readableData,
 932                                                offset);
 933
 934     // Type label relationship
 935     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 936                                                EmptyOptional(),
 937                                                EmptyOptional(),
 938                                                LabelsAndEventClasses::TYPE_GUID,
 939                                                readableData,
 940                                                offset);
 941
 942     // Network - Inference relationship
 943     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 944                                                EmptyOptional(),
 945                                                optNetGuid,
 946                                                EmptyOptional(),
 947                                                readableData,
 948                                                offset);
 949
 950     // Start Inference life
 951     // Event packet - timeline, threadId, eventGuid
 952     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 953
 954     // Inference - event relationship
 955     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
 956                                                EmptyOptional(),
 957                                                EmptyOptional(),
 958                                                EmptyOptional(),
 959                                                readableData,
 960                                                offset);
 961
 962     // Event - event class relationship
 963     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
 964                                                EmptyOptional(),
 965                                                EmptyOptional(),
 966                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
 967                                                readableData,
 968                                                offset);
 969
 970     // Execution
 971     // Input workload execution
 972     // Input workload execution entity
 973     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 974
 975     // Entity - Type relationship
 976     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 977                                                EmptyOptional(),
 978                                                EmptyOptional(),
 979                                                LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
 980                                                readableData,
 981                                                offset);
 982
 983     // Type label relationship
 984     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
 985                                                EmptyOptional(),
 986                                                EmptyOptional(),
 987                                                LabelsAndEventClasses::TYPE_GUID,
 988                                                readableData,
 989                                                offset);
 990
 991     // Inference - Workload execution relationship
 992     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
 993                                                EmptyOptional(),
 994                                                EmptyOptional(),
 995                                                EmptyOptional(),
 996                                                readableData,
 997                                                offset);
 998
 999     // Workload - Workload execution relationship
1000     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1001                                                EmptyOptional(),
1002                                                EmptyOptional(),
1003                                                EmptyOptional(),
1004                                                readableData,
1005                                                offset);
1006
1007     // Start Input workload execution life
1008     // Event packet - timeline, threadId, eventGuid
1009     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1010
1011     // Input workload execution - event relationship
1012     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1013                                                EmptyOptional(),
1014                                                EmptyOptional(),
1015                                                EmptyOptional(),
1016                                                readableData,
1017                                                offset);
1018
1019     // Event - event class relationship
1020     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1021                                                EmptyOptional(),
1022                                                EmptyOptional(),
1023                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1024                                                readableData,
1025                                                offset);
1026
1027     // End of Input workload execution life
1028     // Event packet - timeline, threadId, eventGuid
1029     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1030
1031     // Input workload execution - event relationship
1032     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1033                                                EmptyOptional(),
1034                                                EmptyOptional(),
1035                                                EmptyOptional(),
1036                                                readableData,
1037                                                offset);
1038
1039     // Event - event class relationship
1040     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1041                                                EmptyOptional(),
1042                                                EmptyOptional(),
1043                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1044                                                readableData,
1045                                                offset);
1046
1047     // Conv2d workload execution
1048     // Conv2d workload execution entity
1049     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
1050
1051     // Entity - Type relationship
1052     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1053                                                EmptyOptional(),
1054                                                EmptyOptional(),
1055                                                LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1056                                                readableData,
1057                                                offset);
1058
1059     // Type label relationship
1060     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1061                                                EmptyOptional(),
1062                                                EmptyOptional(),
1063                                                LabelsAndEventClasses::TYPE_GUID,
1064                                                readableData,
1065                                                offset);
1066
1067     // Inference - Workload execution relationship
1068     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1069                                                EmptyOptional(),
1070                                                EmptyOptional(),
1071                                                EmptyOptional(),
1072                                                readableData,
1073                                                offset);
1074
1075     // Workload - Workload execution relationship
1076     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1077                                                EmptyOptional(),
1078                                                EmptyOptional(),
1079                                                EmptyOptional(),
1080                                                readableData,
1081                                                offset);
1082
1083     // Start Conv2d workload execution life
1084     // Event packet - timeline, threadId, eventGuid
1085     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1086
1087     // Conv2d workload execution - event relationship
1088     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1089                                                EmptyOptional(),
1090                                                EmptyOptional(),
1091                                                EmptyOptional(),
1092                                                readableData,
1093                                                offset);
1094
1095     // Event - event class relationship
1096     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1097                                                EmptyOptional(),
1098                                                EmptyOptional(),
1099                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1100                                                readableData,
1101                                                offset);
1102
1103     // End of Conv2d workload execution life
1104     // Event packet - timeline, threadId, eventGuid
1105     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1106
1107     // Conv2d workload execution - event relationship
1108     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1109                                                EmptyOptional(),
1110                                                EmptyOptional(),
1111                                                EmptyOptional(),
1112                                                readableData,
1113                                                offset);
1114
1115     // Event - event class relationship
1116     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1117                                                EmptyOptional(),
1118                                                EmptyOptional(),
1119                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1120                                                readableData,
1121                                                offset);
1122
1123     // Activation workload execution
1124     // Activation workload execution entity
1125     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
1126
1127     // Entity - Type relationship
1128     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1129                                                EmptyOptional(),
1130                                                EmptyOptional(),
1131                                                LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1132                                                readableData,
1133                                                offset);
1134
1135     // Type label relationship
1136     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1137                                                EmptyOptional(),
1138                                                EmptyOptional(),
1139                                                LabelsAndEventClasses::TYPE_GUID,
1140                                                readableData,
1141                                                offset);
1142
1143     // Inference - Workload execution relationship
1144     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1145                                                EmptyOptional(),
1146                                                EmptyOptional(),
1147                                                EmptyOptional(),
1148                                                readableData,
1149                                                offset);
1150
1151     // Workload - Workload execution relationship
1152     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1153                                                EmptyOptional(),
1154                                                EmptyOptional(),
1155                                                EmptyOptional(),
1156                                                readableData,
1157                                                offset);
1158
1159     // Start Activation workload execution life
1160     // Event packet - timeline, threadId, eventGuid
1161     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1162
1163     // Activation workload execution - event relationship
1164     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1165                                                EmptyOptional(),
1166                                                EmptyOptional(),
1167                                                EmptyOptional(),
1168                                                readableData,
1169                                                offset);
1170
1171     // Event - event class relationship
1172     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1173                                                EmptyOptional(),
1174                                                EmptyOptional(),
1175                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1176                                                readableData,
1177                                                offset);
1178
1179     // End of Activation workload execution life
1180     // Event packet - timeline, threadId, eventGuid
1181     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1182
1183     // Activation workload execution - event relationship
1184     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1185                                                EmptyOptional(),
1186                                                EmptyOptional(),
1187                                                EmptyOptional(),
1188                                                readableData,
1189                                                offset);
1190
1191     // Event - event class relationship
1192     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1193                                                EmptyOptional(),
1194                                                EmptyOptional(),
1195                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1196                                                readableData,
1197                                                offset);
1198
1199     // Output workload execution
1200     // Output workload execution entity
1201     VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
1202
1203     // Entity - Type relationship
1204     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1205                                                EmptyOptional(),
1206                                                EmptyOptional(),
1207                                                LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
1208                                                readableData,
1209                                                offset);
1210
1211     // Type label relationship
1212     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
1213                                                EmptyOptional(),
1214                                                EmptyOptional(),
1215                                                LabelsAndEventClasses::TYPE_GUID,
1216                                                readableData,
1217                                                offset);
1218
1219     // Inference - Workload execution relationship
1220     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1221                                                EmptyOptional(),
1222                                                EmptyOptional(),
1223                                                EmptyOptional(),
1224                                                readableData,
1225                                                offset);
1226
1227     // Workload - Workload execution relationship
1228     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
1229                                                EmptyOptional(),
1230                                                EmptyOptional(),
1231                                                EmptyOptional(),
1232                                                readableData,
1233                                                offset);
1234
1235     // Start Output workload execution life
1236     // Event packet - timeline, threadId, eventGuid
1237     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1238
1239     // Output workload execution - event relationship
1240     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1241                                                EmptyOptional(),
1242                                                EmptyOptional(),
1243                                                EmptyOptional(),
1244                                                readableData,
1245                                                offset);
1246
1247     // Event - event class relationship
1248     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1249                                                EmptyOptional(),
1250                                                EmptyOptional(),
1251                                                LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
1252                                                readableData,
1253                                                offset);
1254
1255     // End of Normalize workload execution life
1256     // Event packet - timeline, threadId, eventGuid
1257     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1258
1259     // Output workload execution - event relationship
1260     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1261                                                EmptyOptional(),
1262                                                EmptyOptional(),
1263                                                EmptyOptional(),
1264                                                readableData,
1265                                                offset);
1266
1267     // Event - event class relationship
1268     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1269                                                EmptyOptional(),
1270                                                EmptyOptional(),
1271                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1272                                                readableData,
1273                                                offset);
1274
1275     // End of Inference life
1276     // Event packet - timeline, threadId, eventGuid
1277     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
1278
1279     // Inference - event relationship
1280     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
1281                                                EmptyOptional(),
1282                                                EmptyOptional(),
1283                                                EmptyOptional(),
1284                                                readableData,
1285                                                offset);
1286
1287     // Event - event class relationship
1288     VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
1289                                                EmptyOptional(),
1290                                                EmptyOptional(),
1291                                                LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
1292                                                readableData,
1293                                                offset);
1294
1295     bufferManager.MarkRead(inferenceReadableBuffer);
1296 }