unittests/XRay/FDRBlockVerifierTest.cpp

   1 //===- llvm/unittest/XRay/FDRBlockVerifierTest.cpp --------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 #include "llvm/Testing/Support/Error.h"
   9 #include "llvm/XRay/BlockIndexer.h"
  10 #include "llvm/XRay/BlockVerifier.h"
  11 #include "llvm/XRay/FDRLogBuilder.h"
  12 #include "llvm/XRay/FDRRecords.h"
  13 #include "gmock/gmock.h"
  14 #include "gtest/gtest.h"
  15
  16 namespace llvm {
  17 namespace xray {
  18 namespace {
  19
  20 using ::testing::ElementsAre;
  21 using ::testing::Not;
  22 using ::testing::SizeIs;
  23
  24 TEST(FDRBlockVerifierTest, ValidBlocksV3) {
  25   auto Block0 = LogBuilder()
  26                     .add<BufferExtents>(80)
  27                     .add<NewBufferRecord>(1)
  28                     .add<WallclockRecord>(1, 2)
  29                     .add<PIDRecord>(1)
  30                     .add<NewCPUIDRecord>(1, 2)
  31                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  32                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  33                     .consume();
  34   auto Block1 = LogBuilder()
  35                     .add<BufferExtents>(80)
  36                     .add<NewBufferRecord>(1)
  37                     .add<WallclockRecord>(1, 2)
  38                     .add<PIDRecord>(1)
  39                     .add<NewCPUIDRecord>(1, 2)
  40                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  41                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  42                     .consume();
  43   auto Block2 = LogBuilder()
  44                     .add<BufferExtents>(80)
  45                     .add<NewBufferRecord>(2)
  46                     .add<WallclockRecord>(1, 2)
  47                     .add<PIDRecord>(1)
  48                     .add<NewCPUIDRecord>(2, 2)
  49                     .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  50                     .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  51                     .consume();
  52   BlockIndexer::Index Index;
  53   BlockIndexer Indexer(Index);
  54   for (auto B : {std::ref(Block0), std::ref(Block1), std::ref(Block2)}) {
  55     for (auto &R : B.get())
  56       ASSERT_FALSE(errorToBool(R->apply(Indexer)));
  57     ASSERT_FALSE(errorToBool(Indexer.flush()));
  58   }
  59
  60   BlockVerifier Verifier;
  61   for (auto &ProcessThreadBlocks : Index) {
  62     auto &Blocks = ProcessThreadBlocks.second;
  63     for (auto &B : Blocks) {
  64       for (auto *R : B.Records)
  65         ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  66       ASSERT_FALSE(errorToBool(Verifier.verify()));
  67       Verifier.reset();
  68     }
  69   }
  70 }
  71
  72 TEST(FDRBlockVerifierTest, MissingPIDRecord) {
  73   auto Block = LogBuilder()
  74                    .add<BufferExtents>(20)
  75                    .add<NewBufferRecord>(1)
  76                    .add<WallclockRecord>(1, 2)
  77                    .add<NewCPUIDRecord>(1, 2)
  78                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  79                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  80                    .consume();
  81   BlockVerifier Verifier;
  82   for (auto &R : Block)
  83     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  84   ASSERT_FALSE(errorToBool(Verifier.verify()));
  85 }
  86
  87 TEST(FDRBlockVerifierTest, MissingBufferExtents) {
  88   auto Block = LogBuilder()
  89                    .add<NewBufferRecord>(1)
  90                    .add<WallclockRecord>(1, 2)
  91                    .add<NewCPUIDRecord>(1, 2)
  92                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
  93                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
  94                    .consume();
  95   BlockVerifier Verifier;
  96   for (auto &R : Block)
  97     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
  98   ASSERT_FALSE(errorToBool(Verifier.verify()));
  99 }
 100
 101 TEST(FDRBlockVerifierTest, IgnoreRecordsAfterEOB) {
 102   auto Block = LogBuilder()
 103                    .add<NewBufferRecord>(1)
 104                    .add<WallclockRecord>(1, 2)
 105                    .add<NewCPUIDRecord>(1, 2)
 106                    .add<EndBufferRecord>()
 107                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
 108                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
 109                    .consume();
 110   BlockVerifier Verifier;
 111   for (auto &R : Block)
 112     ASSERT_FALSE(errorToBool(R->apply(Verifier)));
 113   ASSERT_FALSE(errorToBool(Verifier.verify()));
 114 }
 115
 116 TEST(FDRBlockVerifierTest, MalformedV2) {
 117   auto Block = LogBuilder()
 118                    .add<NewBufferRecord>(1)
 119                    .add<WallclockRecord>(1, 2)
 120                    .add<NewCPUIDRecord>(1, 2)
 121                    .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
 122                    .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
 123                    .add<NewBufferRecord>(2)
 124                    .consume();
 125   BlockVerifier Verifier;
 126
 127   ASSERT_THAT(Block, SizeIs(6u));
 128   EXPECT_THAT_ERROR(Block[0]->apply(Verifier), Succeeded());
 129   EXPECT_THAT_ERROR(Block[1]->apply(Verifier), Succeeded());
 130   EXPECT_THAT_ERROR(Block[2]->apply(Verifier), Succeeded());
 131   EXPECT_THAT_ERROR(Block[3]->apply(Verifier), Succeeded());
 132   EXPECT_THAT_ERROR(Block[4]->apply(Verifier), Succeeded());
 133   EXPECT_THAT_ERROR(Block[5]->apply(Verifier), Failed());
 134 }
 135
 136 } // namespace
 137 } // namespace xray
 138 } // namespace llvm