1 //===- llvm/unittest/XRay/FDRTraceWriterTest.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 a utility that can write out XRay FDR Mode formatted trace files.
10 //
11 //===----------------------------------------------------------------------===//
12 #include "llvm/XRay/FDRTraceWriter.h"
13 #include "llvm/Support/raw_ostream.h"
14 #include "llvm/XRay/FDRLogBuilder.h"
15 #include "llvm/XRay/FDRRecords.h"
16 #include "llvm/XRay/Trace.h"
17 #include "gmock/gmock.h"
18 #include "gtest/gtest.h"
19 #include <string>
20 
21 namespace llvm {
22 namespace xray {
23 namespace {
24 
25 using testing::ElementsAre;
26 using testing::Eq;
27 using testing::Field;
28 using testing::IsEmpty;
29 using testing::Not;
30 
31 // We want to be able to create an instance of an FDRTraceWriter and associate
32 // it with a stream, which could be loaded and turned into a Trace instance.
33 // This test writes out version 3 trace logs.
TEST(FDRTraceWriterTest,WriteToStringBufferVersion3)34 TEST(FDRTraceWriterTest, WriteToStringBufferVersion3) {
35   std::string Data;
36   raw_string_ostream OS(Data);
37   XRayFileHeader H;
38   H.Version = 3;
39   H.Type = 1;
40   H.ConstantTSC = true;
41   H.NonstopTSC = true;
42   H.CycleFrequency = 3e9;
43   FDRTraceWriter Writer(OS, H);
44   auto L = LogBuilder()
45                .add<BufferExtents>(80)
46                .add<NewBufferRecord>(1)
47                .add<WallclockRecord>(1, 1)
48                .add<PIDRecord>(1)
49                .add<NewCPUIDRecord>(1, 2)
50                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
51                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
52                .consume();
53   for (auto &P : L)
54     ASSERT_FALSE(errorToBool(P->apply(Writer)));
55   OS.flush();
56 
57   // Then from here we load the Trace file.
58   DataExtractor DE(Data, sys::IsLittleEndianHost, 8);
59   auto TraceOrErr = loadTrace(DE, true);
60   if (!TraceOrErr)
61     FAIL() << TraceOrErr.takeError();
62   auto &Trace = TraceOrErr.get();
63 
64   ASSERT_THAT(Trace, Not(IsEmpty()));
65   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::FuncId, Eq(1)),
66                                  Field(&XRayRecord::FuncId, Eq(1))));
67   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::TId, Eq(1u)),
68                                  Field(&XRayRecord::TId, Eq(1u))));
69   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::PId, Eq(1u)),
70                                  Field(&XRayRecord::PId, Eq(1u))));
71   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::CPU, Eq(1u)),
72                                  Field(&XRayRecord::CPU, Eq(1u))));
73   EXPECT_THAT(Trace,
74               ElementsAre(Field(&XRayRecord::Type, Eq(RecordTypes::ENTER)),
75                           Field(&XRayRecord::Type, Eq(RecordTypes::EXIT))));
76 }
77 
78 // This version is almost exactly the same as above, except writing version 2
79 // logs, without the PID records.
TEST(FDRTraceWriterTest,WriteToStringBufferVersion2)80 TEST(FDRTraceWriterTest, WriteToStringBufferVersion2) {
81   std::string Data;
82   raw_string_ostream OS(Data);
83   XRayFileHeader H;
84   H.Version = 2;
85   H.Type = 1;
86   H.ConstantTSC = true;
87   H.NonstopTSC = true;
88   H.CycleFrequency = 3e9;
89   FDRTraceWriter Writer(OS, H);
90   auto L = LogBuilder()
91                .add<BufferExtents>(64)
92                .add<NewBufferRecord>(1)
93                .add<WallclockRecord>(1, 1)
94                .add<NewCPUIDRecord>(1, 2)
95                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
96                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
97                .consume();
98   for (auto &P : L)
99     ASSERT_FALSE(errorToBool(P->apply(Writer)));
100   OS.flush();
101 
102   // Then from here we load the Trace file.
103   DataExtractor DE(Data, sys::IsLittleEndianHost, 8);
104   auto TraceOrErr = loadTrace(DE, true);
105   if (!TraceOrErr)
106     FAIL() << TraceOrErr.takeError();
107   auto &Trace = TraceOrErr.get();
108 
109   ASSERT_THAT(Trace, Not(IsEmpty()));
110   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::FuncId, Eq(1)),
111                                  Field(&XRayRecord::FuncId, Eq(1))));
112   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::TId, Eq(1u)),
113                                  Field(&XRayRecord::TId, Eq(1u))));
114   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::CPU, Eq(1u)),
115                                  Field(&XRayRecord::CPU, Eq(1u))));
116   EXPECT_THAT(Trace,
117               ElementsAre(Field(&XRayRecord::Type, Eq(RecordTypes::ENTER)),
118                           Field(&XRayRecord::Type, Eq(RecordTypes::EXIT))));
119 }
120 
121 // This covers version 1 of the log, without a BufferExtents record but has an
122 // explicit EndOfBuffer record.
TEST(FDRTraceWriterTest,WriteToStringBufferVersion1)123 TEST(FDRTraceWriterTest, WriteToStringBufferVersion1) {
124   std::string Data;
125   raw_string_ostream OS(Data);
126   XRayFileHeader H;
127   H.Version = 1;
128   H.Type = 1;
129   H.ConstantTSC = true;
130   H.NonstopTSC = true;
131   H.CycleFrequency = 3e9;
132   // Write the size of buffers out, arbitrarily it's 4k.
133   constexpr uint64_t BufferSize = 4096;
134   std::memcpy(H.FreeFormData, reinterpret_cast<const char *>(&BufferSize),
135               sizeof(BufferSize));
136   FDRTraceWriter Writer(OS, H);
137   OS.flush();
138 
139   // Ensure that at this point the Data buffer has the file header serialized
140   // size.
141   ASSERT_THAT(Data.size(), Eq(32u));
142   auto L = LogBuilder()
143                .add<NewBufferRecord>(1)
144                .add<WallclockRecord>(1, 1)
145                .add<NewCPUIDRecord>(1, 2)
146                .add<FunctionRecord>(RecordTypes::ENTER, 1, 1)
147                .add<FunctionRecord>(RecordTypes::EXIT, 1, 100)
148                .add<EndBufferRecord>()
149                .consume();
150   for (auto &P : L)
151     ASSERT_FALSE(errorToBool(P->apply(Writer)));
152 
153   // We need to pad the buffer with 4016 (4096 - 80) bytes of zeros.
154   OS.write_zeros(4016);
155   OS.flush();
156 
157   // For version 1 of the log, we need the whole buffer to be the size of the
158   // file header plus 32.
159   ASSERT_THAT(Data.size(), Eq(BufferSize + 32));
160 
161   // Then from here we load the Trace file.
162   DataExtractor DE(Data, sys::IsLittleEndianHost, 8);
163   auto TraceOrErr = loadTrace(DE, true);
164   if (!TraceOrErr)
165     FAIL() << TraceOrErr.takeError();
166   auto &Trace = TraceOrErr.get();
167 
168   ASSERT_THAT(Trace, Not(IsEmpty()));
169   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::FuncId, Eq(1)),
170                                  Field(&XRayRecord::FuncId, Eq(1))));
171   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::TId, Eq(1u)),
172                                  Field(&XRayRecord::TId, Eq(1u))));
173   EXPECT_THAT(Trace, ElementsAre(Field(&XRayRecord::CPU, Eq(1u)),
174                                  Field(&XRayRecord::CPU, Eq(1u))));
175   EXPECT_THAT(Trace,
176               ElementsAre(Field(&XRayRecord::Type, Eq(RecordTypes::ENTER)),
177                           Field(&XRayRecord::Type, Eq(RecordTypes::EXIT))));
178 }
179 
180 } // namespace
181 } // namespace xray
182 } // namespace llvm
183