1 //===-- xray_fdr_log_writer.h ---------------------------------------------===// 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 #ifndef COMPILER_RT_LIB_XRAY_XRAY_FDR_LOG_WRITER_H_ 13 #define COMPILER_RT_LIB_XRAY_XRAY_FDR_LOG_WRITER_H_ 14 15 #include "xray_buffer_queue.h" 16 #include "xray_fdr_log_records.h" 17 #include <functional> 18 #include <tuple> 19 #include <type_traits> 20 #include <utility> 21 22 namespace __xray { 23 24 template <size_t Index> struct SerializerImpl { 25 template <class Tuple, 26 typename std::enable_if< 27 Index<std::tuple_size< 28 typename std::remove_reference<Tuple>::type>::value, 29 int>::type = 0> static void serializeTo(char *Buffer, 30 Tuple &&T) { 31 auto P = reinterpret_cast<const char *>(&std::get<Index>(T)); 32 constexpr auto Size = sizeof(std::get<Index>(T)); 33 internal_memcpy(Buffer, P, Size); 34 SerializerImpl<Index + 1>::serializeTo(Buffer + Size, 35 std::forward<Tuple>(T)); 36 } 37 38 template <class Tuple, 39 typename std::enable_if< 40 Index >= std::tuple_size<typename std::remove_reference< 41 Tuple>::type>::value, 42 int>::type = 0> 43 static void serializeTo(char *, Tuple &&) {} 44 }; 45 46 using Serializer = SerializerImpl<0>; 47 48 template <class Tuple, size_t Index> struct AggregateSizesImpl { 49 static constexpr size_t value = 50 sizeof(typename std::tuple_element<Index, Tuple>::type) + 51 AggregateSizesImpl<Tuple, Index - 1>::value; 52 }; 53 54 template <class Tuple> struct AggregateSizesImpl<Tuple, 0> { 55 static constexpr size_t value = 56 sizeof(typename std::tuple_element<0, Tuple>::type); 57 }; 58 59 template <class Tuple> struct AggregateSizes { 60 static constexpr size_t value = 61 AggregateSizesImpl<Tuple, std::tuple_size<Tuple>::value - 1>::value; 62 }; 63 64 template <MetadataRecord::RecordKinds Kind, class... DataTypes> 65 MetadataRecord createMetadataRecord(DataTypes &&... Ds) { 66 static_assert(AggregateSizes<std::tuple<DataTypes...>>::value <= 67 sizeof(MetadataRecord) - 1, 68 "Metadata payload longer than metadata buffer!"); 69 MetadataRecord R; 70 R.Type = 1; 71 R.RecordKind = static_cast<uint8_t>(Kind); 72 Serializer::serializeTo(R.Data, 73 std::make_tuple(std::forward<DataTypes>(Ds)...)); 74 return R; 75 } 76 77 class FDRLogWriter { 78 BufferQueue::Buffer &Buffer; 79 char *NextRecord = nullptr; 80 81 template <class T> void writeRecord(const T &R) { 82 internal_memcpy(NextRecord, reinterpret_cast<const char *>(&R), sizeof(T)); 83 NextRecord += sizeof(T); 84 // We need this atomic fence here to ensure that other threads attempting to 85 // read the bytes in the buffer will see the writes committed before the 86 // extents are updated. 87 atomic_thread_fence(memory_order_release); 88 atomic_fetch_add(Buffer.Extents, sizeof(T), memory_order_acq_rel); 89 } 90 91 public: 92 explicit FDRLogWriter(BufferQueue::Buffer &B, char *P) 93 : Buffer(B), NextRecord(P) { 94 DCHECK_NE(Buffer.Data, nullptr); 95 DCHECK_NE(NextRecord, nullptr); 96 } 97 98 explicit FDRLogWriter(BufferQueue::Buffer &B) 99 : FDRLogWriter(B, static_cast<char *>(B.Data)) {} 100 101 template <MetadataRecord::RecordKinds Kind, class... Data> 102 bool writeMetadata(Data &&... Ds) { 103 // TODO: Check boundary conditions: 104 // 1) Buffer is full, and cannot handle one metadata record. 105 // 2) Buffer queue is finalising. 106 writeRecord(createMetadataRecord<Kind>(std::forward<Data>(Ds)...)); 107 return true; 108 } 109 110 template <size_t N> size_t writeMetadataRecords(MetadataRecord (&Recs)[N]) { 111 constexpr auto Size = sizeof(MetadataRecord) * N; 112 internal_memcpy(NextRecord, reinterpret_cast<const char *>(Recs), Size); 113 NextRecord += Size; 114 // We need this atomic fence here to ensure that other threads attempting to 115 // read the bytes in the buffer will see the writes committed before the 116 // extents are updated. 117 atomic_thread_fence(memory_order_release); 118 atomic_fetch_add(Buffer.Extents, Size, memory_order_acq_rel); 119 return Size; 120 } 121 122 enum class FunctionRecordKind : uint8_t { 123 Enter = 0x00, 124 Exit = 0x01, 125 TailExit = 0x02, 126 EnterArg = 0x03, 127 }; 128 129 bool writeFunction(FunctionRecordKind Kind, int32_t FuncId, int32_t Delta) { 130 FunctionRecord R; 131 R.Type = 0; 132 R.RecordKind = uint8_t(Kind); 133 R.FuncId = FuncId; 134 R.TSCDelta = Delta; 135 writeRecord(R); 136 return true; 137 } 138 139 bool writeFunctionWithArg(FunctionRecordKind Kind, int32_t FuncId, 140 int32_t Delta, uint64_t Arg) { 141 // We need to write the function with arg into the buffer, and then 142 // atomically update the buffer extents. This ensures that any reads 143 // synchronised on the buffer extents record will always see the writes 144 // that happen before the atomic update. 145 FunctionRecord R; 146 R.Type = 0; 147 R.RecordKind = uint8_t(Kind); 148 R.FuncId = FuncId; 149 R.TSCDelta = Delta; 150 MetadataRecord A = 151 createMetadataRecord<MetadataRecord::RecordKinds::CallArgument>(Arg); 152 NextRecord = reinterpret_cast<char *>(internal_memcpy( 153 NextRecord, reinterpret_cast<char *>(&R), sizeof(R))) + 154 sizeof(R); 155 NextRecord = reinterpret_cast<char *>(internal_memcpy( 156 NextRecord, reinterpret_cast<char *>(&A), sizeof(A))) + 157 sizeof(A); 158 // We need this atomic fence here to ensure that other threads attempting to 159 // read the bytes in the buffer will see the writes committed before the 160 // extents are updated. 161 atomic_thread_fence(memory_order_release); 162 atomic_fetch_add(Buffer.Extents, sizeof(R) + sizeof(A), 163 memory_order_acq_rel); 164 return true; 165 } 166 167 bool writeCustomEvent(int32_t Delta, const void *Event, int32_t EventSize) { 168 // We write the metadata record and the custom event data into the buffer 169 // first, before we atomically update the extents for the buffer. This 170 // allows us to ensure that any threads reading the extents of the buffer 171 // will only ever see the full metadata and custom event payload accounted 172 // (no partial writes accounted). 173 MetadataRecord R = 174 createMetadataRecord<MetadataRecord::RecordKinds::CustomEventMarker>( 175 EventSize, Delta); 176 NextRecord = reinterpret_cast<char *>(internal_memcpy( 177 NextRecord, reinterpret_cast<char *>(&R), sizeof(R))) + 178 sizeof(R); 179 NextRecord = reinterpret_cast<char *>( 180 internal_memcpy(NextRecord, Event, EventSize)) + 181 EventSize; 182 183 // We need this atomic fence here to ensure that other threads attempting to 184 // read the bytes in the buffer will see the writes committed before the 185 // extents are updated. 186 atomic_thread_fence(memory_order_release); 187 atomic_fetch_add(Buffer.Extents, sizeof(R) + EventSize, 188 memory_order_acq_rel); 189 return true; 190 } 191 192 bool writeTypedEvent(int32_t Delta, uint16_t EventType, const void *Event, 193 int32_t EventSize) { 194 // We do something similar when writing out typed events, see 195 // writeCustomEvent(...) above for details. 196 MetadataRecord R = 197 createMetadataRecord<MetadataRecord::RecordKinds::TypedEventMarker>( 198 EventSize, Delta, EventType); 199 NextRecord = reinterpret_cast<char *>(internal_memcpy( 200 NextRecord, reinterpret_cast<char *>(&R), sizeof(R))) + 201 sizeof(R); 202 NextRecord = reinterpret_cast<char *>( 203 internal_memcpy(NextRecord, Event, EventSize)) + 204 EventSize; 205 206 // We need this atomic fence here to ensure that other threads attempting to 207 // read the bytes in the buffer will see the writes committed before the 208 // extents are updated. 209 atomic_thread_fence(memory_order_release); 210 atomic_fetch_add(Buffer.Extents, EventSize, memory_order_acq_rel); 211 return true; 212 } 213 214 char *getNextRecord() const { return NextRecord; } 215 216 void resetRecord() { 217 NextRecord = reinterpret_cast<char *>(Buffer.Data); 218 atomic_store(Buffer.Extents, 0, memory_order_release); 219 } 220 221 void undoWrites(size_t B) { 222 DCHECK_GE(NextRecord - B, reinterpret_cast<char *>(Buffer.Data)); 223 NextRecord -= B; 224 atomic_fetch_sub(Buffer.Extents, B, memory_order_acq_rel); 225 } 226 227 }; // namespace __xray 228 229 } // namespace __xray 230 231 #endif // COMPILER-RT_LIB_XRAY_XRAY_FDR_LOG_WRITER_H_ 232