1 //===- llvm/unittest/XRay/FDRProducerConsumerTest.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 //
9 // Test for round-trip record writing and reading.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "llvm/Support/DataExtractor.h"
13 #include "llvm/Support/raw_ostream.h"
14 #include "llvm/XRay/FDRLogBuilder.h"
15 #include "llvm/XRay/FDRRecordConsumer.h"
16 #include "llvm/XRay/FDRRecordProducer.h"
17 #include "llvm/XRay/FDRRecords.h"
18 #include "llvm/XRay/FDRTraceWriter.h"
19 #include "llvm/XRay/FileHeaderReader.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22 #include <string>
23 #include <tuple>
24 
25 namespace llvm {
26 namespace xray {
27 namespace {
28 
29 using ::testing::Eq;
30 using ::testing::IsEmpty;
31 using ::testing::Not;
32 using ::testing::SizeIs;
33 
34 template <class RecordType> std::unique_ptr<Record> MakeRecord();
35 
36 template <> std::unique_ptr<Record> MakeRecord<NewBufferRecord>() {
37   return std::make_unique<NewBufferRecord>(1);
38 }
39 
40 template <> std::unique_ptr<Record> MakeRecord<NewCPUIDRecord>() {
41   return std::make_unique<NewCPUIDRecord>(1, 2);
42 }
43 
44 template <> std::unique_ptr<Record> MakeRecord<TSCWrapRecord>() {
45   return std::make_unique<TSCWrapRecord>(1);
46 }
47 
48 template <> std::unique_ptr<Record> MakeRecord<WallclockRecord>() {
49   return std::make_unique<WallclockRecord>(1, 2);
50 }
51 
52 template <> std::unique_ptr<Record> MakeRecord<CustomEventRecord>() {
53   return std::make_unique<CustomEventRecord>(4, 1, 2, "data");
54 }
55 
56 template <> std::unique_ptr<Record> MakeRecord<CallArgRecord>() {
57   return std::make_unique<CallArgRecord>(1);
58 }
59 
60 template <> std::unique_ptr<Record> MakeRecord<PIDRecord>() {
61   return std::make_unique<PIDRecord>(1);
62 }
63 
64 template <> std::unique_ptr<Record> MakeRecord<FunctionRecord>() {
65   return std::make_unique<FunctionRecord>(RecordTypes::ENTER, 1, 2);
66 }
67 
68 template <> std::unique_ptr<Record> MakeRecord<CustomEventRecordV5>() {
69   return std::make_unique<CustomEventRecordV5>(4, 1, "data");
70 }
71 
72 template <> std::unique_ptr<Record> MakeRecord<TypedEventRecord>() {
73   return std::make_unique<TypedEventRecord>(4, 1, 2, "data");
74 }
75 
76 template <class T> class RoundTripTest : public ::testing::Test {
77 public:
78   RoundTripTest() : Data(), OS(Data) {
79     H.Version = 4;
80     H.Type = 1;
81     H.ConstantTSC = true;
82     H.NonstopTSC = true;
83     H.CycleFrequency = 3e9;
84 
85     Writer = std::make_unique<FDRTraceWriter>(OS, H);
86     Rec = MakeRecord<T>();
87   }
88 
89 protected:
90   std::string Data;
91   raw_string_ostream OS;
92   XRayFileHeader H;
93   std::unique_ptr<FDRTraceWriter> Writer;
94   std::unique_ptr<Record> Rec;
95 };
96 
97 TYPED_TEST_SUITE_P(RoundTripTest);
98 
99 template <class T> class RoundTripTestV5 : public ::testing::Test {
100 public:
101   RoundTripTestV5() : Data(), OS(Data) {
102     H.Version = 5;
103     H.Type = 1;
104     H.ConstantTSC = true;
105     H.NonstopTSC = true;
106     H.CycleFrequency = 3e9;
107 
108     Writer = std::make_unique<FDRTraceWriter>(OS, H);
109     Rec = MakeRecord<T>();
110   }
111 
112 protected:
113   std::string Data;
114   raw_string_ostream OS;
115   XRayFileHeader H;
116   std::unique_ptr<FDRTraceWriter> Writer;
117   std::unique_ptr<Record> Rec;
118 };
119 
120 TYPED_TEST_SUITE_P(RoundTripTestV5);
121 
122 // This test ensures that the writing and reading implementations are in sync --
123 // that given write(read(write(R))) == R.
124 TYPED_TEST_P(RoundTripTest, RoundTripsSingleValue) {
125   // Always write a buffer extents record which will cover the correct size of
126   // the record, for version 3 and up.
127   BufferExtents BE(200);
128   ASSERT_FALSE(errorToBool(BE.apply(*this->Writer)));
129   auto &R = this->Rec;
130   ASSERT_FALSE(errorToBool(R->apply(*this->Writer)));
131   this->OS.flush();
132 
133   DataExtractor DE(this->Data, sys::IsLittleEndianHost, 8);
134   uint64_t OffsetPtr = 0;
135   auto HeaderOrErr = readBinaryFormatHeader(DE, OffsetPtr);
136   if (!HeaderOrErr)
137     FAIL() << HeaderOrErr.takeError();
138 
139   FileBasedRecordProducer P(HeaderOrErr.get(), DE, OffsetPtr);
140   std::vector<std::unique_ptr<Record>> Records;
141   LogBuilderConsumer C(Records);
142   while (DE.isValidOffsetForDataOfSize(OffsetPtr, 1)) {
143     auto R = P.produce();
144     if (!R)
145       FAIL() << R.takeError();
146     if (auto E = C.consume(std::move(R.get())))
147       FAIL() << E;
148   }
149   ASSERT_THAT(Records, Not(IsEmpty()));
150   std::string Data2;
151   raw_string_ostream OS2(Data2);
152   FDRTraceWriter Writer2(OS2, this->H);
153   for (auto &P : Records)
154     ASSERT_FALSE(errorToBool(P->apply(Writer2)));
155   OS2.flush();
156 
157   EXPECT_EQ(Data2.substr(sizeof(XRayFileHeader)),
158             this->Data.substr(sizeof(XRayFileHeader)));
159   ASSERT_THAT(Records, SizeIs(2));
160   EXPECT_THAT(Records[1]->getRecordType(), Eq(R->getRecordType()));
161 }
162 
163 REGISTER_TYPED_TEST_SUITE_P(RoundTripTest, RoundTripsSingleValue);
164 
165 // We duplicate the above case for the V5 version using different types and
166 // encodings.
167 TYPED_TEST_P(RoundTripTestV5, RoundTripsSingleValue) {
168   BufferExtents BE(200);
169   ASSERT_FALSE(errorToBool(BE.apply(*this->Writer)));
170   auto &R = this->Rec;
171   ASSERT_FALSE(errorToBool(R->apply(*this->Writer)));
172   this->OS.flush();
173 
174   DataExtractor DE(this->Data, sys::IsLittleEndianHost, 8);
175   uint64_t OffsetPtr = 0;
176   auto HeaderOrErr = readBinaryFormatHeader(DE, OffsetPtr);
177   if (!HeaderOrErr)
178     FAIL() << HeaderOrErr.takeError();
179 
180   FileBasedRecordProducer P(HeaderOrErr.get(), DE, OffsetPtr);
181   std::vector<std::unique_ptr<Record>> Records;
182   LogBuilderConsumer C(Records);
183   while (DE.isValidOffsetForDataOfSize(OffsetPtr, 1)) {
184     auto R = P.produce();
185     if (!R)
186       FAIL() << R.takeError();
187     if (auto E = C.consume(std::move(R.get())))
188       FAIL() << E;
189   }
190   ASSERT_THAT(Records, Not(IsEmpty()));
191   std::string Data2;
192   raw_string_ostream OS2(Data2);
193   FDRTraceWriter Writer2(OS2, this->H);
194   for (auto &P : Records)
195     ASSERT_FALSE(errorToBool(P->apply(Writer2)));
196   OS2.flush();
197 
198   EXPECT_EQ(Data2.substr(sizeof(XRayFileHeader)),
199             this->Data.substr(sizeof(XRayFileHeader)));
200   ASSERT_THAT(Records, SizeIs(2));
201   EXPECT_THAT(Records[1]->getRecordType(), Eq(R->getRecordType()));
202 }
203 
204 REGISTER_TYPED_TEST_SUITE_P(RoundTripTestV5, RoundTripsSingleValue);
205 
206 // These are the record types we support for v4 and below.
207 using RecordTypes =
208     ::testing::Types<NewBufferRecord, NewCPUIDRecord, TSCWrapRecord,
209                      WallclockRecord, CustomEventRecord, CallArgRecord,
210                      PIDRecord, FunctionRecord>;
211 INSTANTIATE_TYPED_TEST_SUITE_P(Records, RoundTripTest, RecordTypes, );
212 
213 // For V5, we have two new types we're supporting.
214 using RecordTypesV5 =
215     ::testing::Types<NewBufferRecord, NewCPUIDRecord, TSCWrapRecord,
216                      WallclockRecord, CustomEventRecordV5, TypedEventRecord,
217                      CallArgRecord, PIDRecord, FunctionRecord>;
218 INSTANTIATE_TYPED_TEST_SUITE_P(Records, RoundTripTestV5, RecordTypesV5, );
219 
220 } // namespace
221 } // namespace xray
222 } // namespace llvm
223