Home | History | Annotate | Line # | Download | only in xray 
      1 //===-- xray_fdr_controller.h ---------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file is a part of XRay, a function call tracing system.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 #ifndef COMPILER_RT_LIB_XRAY_XRAY_FDR_CONTROLLER_H_
     14 #define COMPILER_RT_LIB_XRAY_XRAY_FDR_CONTROLLER_H_
     15 
     16 #include <limits>
     17 #include <time.h>
     18 
     19 #include "xray/xray_interface.h"
     20 #include "xray/xray_records.h"
     21 #include "xray_buffer_queue.h"
     22 #include "xray_fdr_log_writer.h"
     23 
     24 namespace __xray {
     25 
     26 template <size_t Version = 5> class FDRController {
     27   BufferQueue *BQ;
     28   BufferQueue::Buffer &B;
     29   FDRLogWriter &W;
     30   int (*WallClockReader)(clockid_t, struct timespec *) = 0;
     31   uint64_t CycleThreshold = 0;
     32 
     33   uint64_t LastFunctionEntryTSC = 0;
     34   uint64_t LatestTSC = 0;
     35   uint16_t LatestCPU = 0;
     36   tid_t TId = 0;
     37   pid_t PId = 0;
     38   bool First = true;
     39 
     40   uint32_t UndoableFunctionEnters = 0;
     41   uint32_t UndoableTailExits = 0;
     42 
     43   bool finalized() const XRAY_NEVER_INSTRUMENT {
     44     return BQ == nullptr || BQ->finalizing();
     45   }
     46 
     47   bool hasSpace(size_t S) XRAY_NEVER_INSTRUMENT {
     48     return B.Data != nullptr && B.Generation == BQ->generation() &&
     49            W.getNextRecord() + S <= reinterpret_cast<char *>(B.Data) + B.Size;
     50   }
     51 
     52   constexpr int32_t mask(int32_t FuncId) const XRAY_NEVER_INSTRUMENT {
     53     return FuncId & ((1 << 29) - 1);
     54   }
     55 
     56   bool getNewBuffer() XRAY_NEVER_INSTRUMENT {
     57     if (BQ->getBuffer(B) != BufferQueue::ErrorCode::Ok)
     58       return false;
     59 
     60     W.resetRecord();
     61     DCHECK_EQ(W.getNextRecord(), B.Data);
     62     LatestTSC = 0;
     63     LatestCPU = 0;
     64     First = true;
     65     UndoableFunctionEnters = 0;
     66     UndoableTailExits = 0;
     67     atomic_store(B.Extents, 0, memory_order_release);
     68     return true;
     69   }
     70 
     71   bool setupNewBuffer() XRAY_NEVER_INSTRUMENT {
     72     if (finalized())
     73       return false;
     74 
     75     DCHECK(hasSpace(sizeof(MetadataRecord) * 3));
     76     TId = GetTid();
     77     PId = internal_getpid();
     78     struct timespec TS {
     79       0, 0
     80     };
     81     WallClockReader(CLOCK_MONOTONIC, &TS);
     82 
     83     MetadataRecord Metadata[] = {
     84         // Write out a MetadataRecord to signify that this is the start of a new
     85         // buffer, associated with a particular thread, with a new CPU. For the
     86         // data, we have 15 bytes to squeeze as much information as we can. At
     87         // this point we only write down the following bytes:
     88         //   - Thread ID (tid_t, cast to 4 bytes type due to Darwin being 8
     89         //   bytes)
     90         createMetadataRecord<MetadataRecord::RecordKinds::NewBuffer>(
     91             static_cast<int32_t>(TId)),
     92 
     93         // Also write the WalltimeMarker record. We only really need microsecond
     94         // precision here, and enforce across platforms that we need 64-bit
     95         // seconds and 32-bit microseconds encoded in the Metadata record.
     96         createMetadataRecord<MetadataRecord::RecordKinds::WalltimeMarker>(
     97             static_cast<int64_t>(TS.tv_sec),
     98             static_cast<int32_t>(TS.tv_nsec / 1000)),
     99 
    100         // Also write the Pid record.
    101         createMetadataRecord<MetadataRecord::RecordKinds::Pid>(
    102             static_cast<int32_t>(PId)),
    103     };
    104 
    105     if (finalized())
    106       return false;
    107     return W.writeMetadataRecords(Metadata);
    108   }
    109 
    110   bool prepareBuffer(size_t S) XRAY_NEVER_INSTRUMENT {
    111     if (finalized())
    112       return returnBuffer();
    113 
    114     if (UNLIKELY(!hasSpace(S))) {
    115       if (!returnBuffer())
    116         return false;
    117       if (!getNewBuffer())
    118         return false;
    119       if (!setupNewBuffer())
    120         return false;
    121     }
    122 
    123     if (First) {
    124       First = false;
    125       W.resetRecord();
    126       atomic_store(B.Extents, 0, memory_order_release);
    127       return setupNewBuffer();
    128     }
    129 
    130     return true;
    131   }
    132 
    133   bool returnBuffer() XRAY_NEVER_INSTRUMENT {
    134     if (BQ == nullptr)
    135       return false;
    136 
    137     First = true;
    138     if (finalized()) {
    139       BQ->releaseBuffer(B); // ignore result.
    140       return false;
    141     }
    142 
    143     return BQ->releaseBuffer(B) == BufferQueue::ErrorCode::Ok;
    144   }
    145 
    146   enum class PreambleResult { NoChange, WroteMetadata, InvalidBuffer };
    147   PreambleResult recordPreamble(uint64_t TSC,
    148                                 uint16_t CPU) XRAY_NEVER_INSTRUMENT {
    149     if (UNLIKELY(LatestCPU != CPU || LatestTSC == 0)) {
    150       // We update our internal tracking state for the Latest TSC and CPU we've
    151       // seen, then write out the appropriate metadata and function records.
    152       LatestTSC = TSC;
    153       LatestCPU = CPU;
    154 
    155       if (B.Generation != BQ->generation())
    156         return PreambleResult::InvalidBuffer;
    157 
    158       W.writeMetadata<MetadataRecord::RecordKinds::NewCPUId>(CPU, TSC);
    159       return PreambleResult::WroteMetadata;
    160     }
    161 
    162     DCHECK_EQ(LatestCPU, CPU);
    163 
    164     if (UNLIKELY(LatestTSC > TSC ||
    165                  TSC - LatestTSC >
    166                      uint64_t{std::numeric_limits<int32_t>::max()})) {
    167       // Either the TSC has wrapped around from the last TSC we've seen or the
    168       // delta is too large to fit in a 32-bit signed integer, so we write a
    169       // wrap-around record.
    170       LatestTSC = TSC;
    171 
    172       if (B.Generation != BQ->generation())
    173         return PreambleResult::InvalidBuffer;
    174 
    175       W.writeMetadata<MetadataRecord::RecordKinds::TSCWrap>(TSC);
    176       return PreambleResult::WroteMetadata;
    177     }
    178 
    179     return PreambleResult::NoChange;
    180   }
    181 
    182   bool rewindRecords(int32_t FuncId, uint64_t TSC,
    183                      uint16_t CPU) XRAY_NEVER_INSTRUMENT {
    184     // Undo one enter record, because at this point we are either at the state
    185     // of:
    186     // - We are exiting a function that we recently entered.
    187     // - We are exiting a function that was the result of a sequence of tail
    188     //   exits, and we can check whether the tail exits can be re-wound.
    189     //
    190     FunctionRecord F;
    191     W.undoWrites(sizeof(FunctionRecord));
    192     if (B.Generation != BQ->generation())
    193       return false;
    194     internal_memcpy(&F, W.getNextRecord(), sizeof(FunctionRecord));
    195 
    196     DCHECK(F.RecordKind ==
    197                uint8_t(FunctionRecord::RecordKinds::FunctionEnter) &&
    198            "Expected to find function entry recording when rewinding.");
    199     DCHECK_EQ(F.FuncId, FuncId & ~(0x0F << 28));
    200 
    201     LatestTSC -= F.TSCDelta;
    202     if (--UndoableFunctionEnters != 0) {
    203       LastFunctionEntryTSC -= F.TSCDelta;
    204       return true;
    205     }
    206 
    207     LastFunctionEntryTSC = 0;
    208     auto RewindingTSC = LatestTSC;
    209     auto RewindingRecordPtr = W.getNextRecord() - sizeof(FunctionRecord);
    210     while (UndoableTailExits) {
    211       if (B.Generation != BQ->generation())
    212         return false;
    213       internal_memcpy(&F, RewindingRecordPtr, sizeof(FunctionRecord));
    214       DCHECK_EQ(F.RecordKind,
    215                 uint8_t(FunctionRecord::RecordKinds::FunctionTailExit));
    216       RewindingTSC -= F.TSCDelta;
    217       RewindingRecordPtr -= sizeof(FunctionRecord);
    218       if (B.Generation != BQ->generation())
    219         return false;
    220       internal_memcpy(&F, RewindingRecordPtr, sizeof(FunctionRecord));
    221 
    222       // This tail call exceeded the threshold duration. It will not be erased.
    223       if ((TSC - RewindingTSC) >= CycleThreshold) {
    224         UndoableTailExits = 0;
    225         return true;
    226       }
    227 
    228       --UndoableTailExits;
    229       W.undoWrites(sizeof(FunctionRecord) * 2);
    230       LatestTSC = RewindingTSC;
    231     }
    232     return true;
    233   }
    234 
    235 public:
    236   template <class WallClockFunc>
    237   FDRController(BufferQueue *BQ, BufferQueue::Buffer &B, FDRLogWriter &W,
    238                 WallClockFunc R, uint64_t C) XRAY_NEVER_INSTRUMENT
    239       : BQ(BQ),
    240         B(B),
    241         W(W),
    242         WallClockReader(R),
    243         CycleThreshold(C) {}
    244 
    245   bool functionEnter(int32_t FuncId, uint64_t TSC,
    246                      uint16_t CPU) XRAY_NEVER_INSTRUMENT {
    247     if (finalized() ||
    248         !prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
    249       return returnBuffer();
    250 
    251     auto PreambleStatus = recordPreamble(TSC, CPU);
    252     if (PreambleStatus == PreambleResult::InvalidBuffer)
    253       return returnBuffer();
    254 
    255     if (PreambleStatus == PreambleResult::WroteMetadata) {
    256       UndoableFunctionEnters = 1;
    257       UndoableTailExits = 0;
    258     } else {
    259       ++UndoableFunctionEnters;
    260     }
    261 
    262     auto Delta = TSC - LatestTSC;
    263     LastFunctionEntryTSC = TSC;
    264     LatestTSC = TSC;
    265     return W.writeFunction(FDRLogWriter::FunctionRecordKind::Enter,
    266                            mask(FuncId), Delta);
    267   }
    268 
    269   bool functionTailExit(int32_t FuncId, uint64_t TSC,
    270                         uint16_t CPU) XRAY_NEVER_INSTRUMENT {
    271     if (finalized())
    272       return returnBuffer();
    273 
    274     if (!prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
    275       return returnBuffer();
    276 
    277     auto PreambleStatus = recordPreamble(TSC, CPU);
    278     if (PreambleStatus == PreambleResult::InvalidBuffer)
    279       return returnBuffer();
    280 
    281     if (PreambleStatus == PreambleResult::NoChange &&
    282         UndoableFunctionEnters != 0 &&
    283         TSC - LastFunctionEntryTSC < CycleThreshold)
    284       return rewindRecords(FuncId, TSC, CPU);
    285 
    286     UndoableTailExits = UndoableFunctionEnters ? UndoableTailExits + 1 : 0;
    287     UndoableFunctionEnters = 0;
    288     auto Delta = TSC - LatestTSC;
    289     LatestTSC = TSC;
    290     return W.writeFunction(FDRLogWriter::FunctionRecordKind::TailExit,
    291                            mask(FuncId), Delta);
    292   }
    293 
    294   bool functionEnterArg(int32_t FuncId, uint64_t TSC, uint16_t CPU,
    295                         uint64_t Arg) XRAY_NEVER_INSTRUMENT {
    296     if (finalized() ||
    297         !prepareBuffer((2 * sizeof(MetadataRecord)) + sizeof(FunctionRecord)) ||
    298         recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
    299       return returnBuffer();
    300 
    301     auto Delta = TSC - LatestTSC;
    302     LatestTSC = TSC;
    303     LastFunctionEntryTSC = 0;
    304     UndoableFunctionEnters = 0;
    305     UndoableTailExits = 0;
    306 
    307     return W.writeFunctionWithArg(FDRLogWriter::FunctionRecordKind::EnterArg,
    308                                   mask(FuncId), Delta, Arg);
    309   }
    310 
    311   bool functionExit(int32_t FuncId, uint64_t TSC,
    312                     uint16_t CPU) XRAY_NEVER_INSTRUMENT {
    313     if (finalized() ||
    314         !prepareBuffer(sizeof(MetadataRecord) + sizeof(FunctionRecord)))
    315       return returnBuffer();
    316 
    317     auto PreambleStatus = recordPreamble(TSC, CPU);
    318     if (PreambleStatus == PreambleResult::InvalidBuffer)
    319       return returnBuffer();
    320 
    321     if (PreambleStatus == PreambleResult::NoChange &&
    322         UndoableFunctionEnters != 0 &&
    323         TSC - LastFunctionEntryTSC < CycleThreshold)
    324       return rewindRecords(FuncId, TSC, CPU);
    325 
    326     auto Delta = TSC - LatestTSC;
    327     LatestTSC = TSC;
    328     UndoableFunctionEnters = 0;
    329     UndoableTailExits = 0;
    330     return W.writeFunction(FDRLogWriter::FunctionRecordKind::Exit, mask(FuncId),
    331                            Delta);
    332   }
    333 
    334   bool customEvent(uint64_t TSC, uint16_t CPU, const void *Event,
    335                    int32_t EventSize) XRAY_NEVER_INSTRUMENT {
    336     if (finalized() ||
    337         !prepareBuffer((2 * sizeof(MetadataRecord)) + EventSize) ||
    338         recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
    339       return returnBuffer();
    340 
    341     auto Delta = TSC - LatestTSC;
    342     LatestTSC = TSC;
    343     UndoableFunctionEnters = 0;
    344     UndoableTailExits = 0;
    345     return W.writeCustomEvent(Delta, Event, EventSize);
    346   }
    347 
    348   bool typedEvent(uint64_t TSC, uint16_t CPU, uint16_t EventType,
    349                   const void *Event, int32_t EventSize) XRAY_NEVER_INSTRUMENT {
    350     if (finalized() ||
    351         !prepareBuffer((2 * sizeof(MetadataRecord)) + EventSize) ||
    352         recordPreamble(TSC, CPU) == PreambleResult::InvalidBuffer)
    353       return returnBuffer();
    354 
    355     auto Delta = TSC - LatestTSC;
    356     LatestTSC = TSC;
    357     UndoableFunctionEnters = 0;
    358     UndoableTailExits = 0;
    359     return W.writeTypedEvent(Delta, EventType, Event, EventSize);
    360   }
    361 
    362   bool flush() XRAY_NEVER_INSTRUMENT {
    363     if (finalized()) {
    364       returnBuffer(); // ignore result.
    365       return true;
    366     }
    367     return returnBuffer();
    368   }
    369 };
    370 
    371 } // namespace __xray
    372 
    373 #endif // COMPILER-RT_LIB_XRAY_XRAY_FDR_CONTROLLER_H_
    374