1 //===-- fdr_log_writer_test.cpp -------------------------------------------===//
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 // This file is a part of XRay, a function call tracing system.
10 //
11 //===----------------------------------------------------------------------===//
12 #include <time.h>
13 
14 #include "test_helpers.h"
15 #include "xray/xray_records.h"
16 #include "xray_fdr_log_writer.h"
17 #include "llvm/Support/DataExtractor.h"
18 #include "llvm/Testing/Support/Error.h"
19 #include "llvm/XRay/Trace.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22 
23 namespace __xray {
24 namespace {
25 
26 static constexpr size_t kSize = 4096;
27 
28 using ::llvm::HasValue;
29 using ::llvm::xray::testing::FuncId;
30 using ::llvm::xray::testing::RecordType;
31 using ::testing::AllOf;
32 using ::testing::ElementsAre;
33 using ::testing::Eq;
34 using ::testing::IsEmpty;
35 using ::testing::IsNull;
36 
37 // Exercise the common code path where we initialize a buffer and are able to
38 // write some records successfully.
39 TEST(FdrLogWriterTest, WriteSomeRecords) {
40   bool Success = false;
41   BufferQueue Buffers(kSize, 1, Success);
42   BufferQueue::Buffer B;
43   ASSERT_EQ(Buffers.getBuffer(B), BufferQueue::ErrorCode::Ok);
44 
45   FDRLogWriter Writer(B);
46   MetadataRecord Preamble[] = {
47       createMetadataRecord<MetadataRecord::RecordKinds::NewBuffer>(int32_t{1}),
48       createMetadataRecord<MetadataRecord::RecordKinds::WalltimeMarker>(
49           int64_t{1}, int32_t{2}),
50       createMetadataRecord<MetadataRecord::RecordKinds::Pid>(int32_t{1}),
51   };
52   ASSERT_THAT(Writer.writeMetadataRecords(Preamble),
53               Eq(sizeof(MetadataRecord) * 3));
54   ASSERT_TRUE(Writer.writeMetadata<MetadataRecord::RecordKinds::NewCPUId>(1));
55   ASSERT_TRUE(
56       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Enter, 1, 1));
57   ASSERT_TRUE(
58       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Exit, 1, 1));
59   ASSERT_EQ(Buffers.releaseBuffer(B), BufferQueue::ErrorCode::Ok);
60   ASSERT_EQ(B.Data, nullptr);
61   ASSERT_EQ(Buffers.finalize(), BufferQueue::ErrorCode::Ok);
62 
63   // We then need to go through each element of the Buffers, and re-create a
64   // flat buffer that we would see if they were laid out in a file. This also
65   // means we need to write out the header manually.
66   std::string Serialized = serialize(Buffers, 3);
67   llvm::DataExtractor DE(Serialized, true, 8);
68   auto TraceOrErr = llvm::xray::loadTrace(DE);
69   EXPECT_THAT_EXPECTED(
70       TraceOrErr,
71       HasValue(ElementsAre(
72           AllOf(FuncId(1), RecordType(llvm::xray::RecordTypes::ENTER)),
73           AllOf(FuncId(1), RecordType(llvm::xray::RecordTypes::EXIT)))));
74 }
75 
76 // Ensure that we can handle buffer re-use.
77 TEST(FdrLogWriterTest, ReuseBuffers) {
78   bool Success = false;
79   BufferQueue Buffers(kSize, 1, Success);
80   BufferQueue::Buffer B;
81   ASSERT_EQ(Buffers.getBuffer(B), BufferQueue::ErrorCode::Ok);
82 
83   FDRLogWriter Writer(B);
84   MetadataRecord Preamble[] = {
85       createMetadataRecord<MetadataRecord::RecordKinds::NewBuffer>(int32_t{1}),
86       createMetadataRecord<MetadataRecord::RecordKinds::WalltimeMarker>(
87           int64_t{1}, int32_t{2}),
88       createMetadataRecord<MetadataRecord::RecordKinds::Pid>(int32_t{1}),
89   };
90 
91   // First we write the first set of records into the single buffer in the
92   // queue which includes one enter and one exit record.
93   ASSERT_THAT(Writer.writeMetadataRecords(Preamble),
94               Eq(sizeof(MetadataRecord) * 3));
95   ASSERT_TRUE(Writer.writeMetadata<MetadataRecord::RecordKinds::NewCPUId>(
96       uint16_t{1}, uint64_t{1}));
97   uint64_t TSC = 1;
98   ASSERT_TRUE(
99       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Enter, 1, TSC++));
100   ASSERT_TRUE(
101       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Exit, 1, TSC++));
102   ASSERT_EQ(Buffers.releaseBuffer(B), BufferQueue::ErrorCode::Ok);
103   ASSERT_THAT(B.Data, IsNull());
104 
105   // Then we re-use the buffer, but only write one record.
106   ASSERT_EQ(Buffers.getBuffer(B), BufferQueue::ErrorCode::Ok);
107   Writer.resetRecord();
108   ASSERT_THAT(Writer.writeMetadataRecords(Preamble),
109               Eq(sizeof(MetadataRecord) * 3));
110   ASSERT_TRUE(Writer.writeMetadata<MetadataRecord::RecordKinds::NewCPUId>(
111       uint16_t{1}, uint64_t{1}));
112   ASSERT_TRUE(
113       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Enter, 1, TSC++));
114   ASSERT_EQ(Buffers.releaseBuffer(B), BufferQueue::ErrorCode::Ok);
115   ASSERT_THAT(B.Data, IsNull());
116   ASSERT_EQ(Buffers.finalize(), BufferQueue::ErrorCode::Ok);
117 
118   // Then we validate that we only see the single enter record.
119   std::string Serialized = serialize(Buffers, 3);
120   llvm::DataExtractor DE(Serialized, true, 8);
121   auto TraceOrErr = llvm::xray::loadTrace(DE);
122   EXPECT_THAT_EXPECTED(
123       TraceOrErr, HasValue(ElementsAre(AllOf(
124                       FuncId(1), RecordType(llvm::xray::RecordTypes::ENTER)))));
125 }
126 
127 TEST(FdrLogWriterTest, UnwriteRecords) {
128   bool Success = false;
129   BufferQueue Buffers(kSize, 1, Success);
130   BufferQueue::Buffer B;
131   ASSERT_EQ(Buffers.getBuffer(B), BufferQueue::ErrorCode::Ok);
132 
133   FDRLogWriter Writer(B);
134   MetadataRecord Preamble[] = {
135       createMetadataRecord<MetadataRecord::RecordKinds::NewBuffer>(int32_t{1}),
136       createMetadataRecord<MetadataRecord::RecordKinds::WalltimeMarker>(
137           int64_t{1}, int32_t{2}),
138       createMetadataRecord<MetadataRecord::RecordKinds::Pid>(int32_t{1}),
139   };
140   ASSERT_THAT(Writer.writeMetadataRecords(Preamble),
141               Eq(sizeof(MetadataRecord) * 3));
142   ASSERT_TRUE(Writer.writeMetadata<MetadataRecord::RecordKinds::NewCPUId>(1));
143   ASSERT_TRUE(
144       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Enter, 1, 1));
145   ASSERT_TRUE(
146       Writer.writeFunction(FDRLogWriter::FunctionRecordKind::Exit, 1, 1));
147   Writer.undoWrites(sizeof(FunctionRecord) * 2);
148   ASSERT_EQ(Buffers.releaseBuffer(B), BufferQueue::ErrorCode::Ok);
149   ASSERT_EQ(B.Data, nullptr);
150   ASSERT_EQ(Buffers.finalize(), BufferQueue::ErrorCode::Ok);
151 
152   // We've un-done the two function records we've written, and now we expect
153   // that we don't have any function records in the trace.
154   std::string Serialized = serialize(Buffers, 3);
155   llvm::DataExtractor DE(Serialized, true, 8);
156   auto TraceOrErr = llvm::xray::loadTrace(DE);
157   EXPECT_THAT_EXPECTED(TraceOrErr, HasValue(IsEmpty()));
158 }
159 
160 } // namespace
161 } // namespace __xray
162