Home | History | Annotate | Download | only in profile 
      1 /*===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===*\
      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 #include "InstrProfiling.h"
     11 #include "InstrProfilingInternal.h"
     12 #ifdef _MSC_VER
     13 /* For _alloca */
     14 #include <malloc.h>
     15 #endif
     16 #include <string.h>
     17 
     18 #define INSTR_PROF_VALUE_PROF_DATA
     19 #include "InstrProfData.inc"
     20 
     21 COMPILER_RT_VISIBILITY void (*FreeHook)(void *) = NULL;
     22 static ProfBufferIO TheBufferIO;
     23 #define VP_BUFFER_SIZE 8 * 1024
     24 static uint8_t BufferIOBuffer[VP_BUFFER_SIZE];
     25 static InstrProfValueData VPDataArray[16];
     26 static uint32_t VPDataArraySize = sizeof(VPDataArray) / sizeof(*VPDataArray);
     27 
     28 COMPILER_RT_VISIBILITY uint8_t *DynamicBufferIOBuffer = 0;
     29 COMPILER_RT_VISIBILITY uint32_t VPBufferSize = 0;
     30 
     31 /* The buffer writer is reponsponsible in keeping writer state
     32  * across the call.
     33  */
     34 COMPILER_RT_VISIBILITY uint32_t lprofBufferWriter(ProfDataIOVec *IOVecs,
     35                                                   uint32_t NumIOVecs,
     36                                                   void **WriterCtx) {
     37   uint32_t I;
     38   char **Buffer = (char **)WriterCtx;
     39   for (I = 0; I < NumIOVecs; I++) {
     40     size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
     41     memcpy(*Buffer, IOVecs[I].Data, Length);
     42     *Buffer += Length;
     43   }
     44   return 0;
     45 }
     46 
     47 static void llvmInitBufferIO(ProfBufferIO *BufferIO, WriterCallback FileWriter,
     48                              void *File, uint8_t *Buffer, uint32_t BufferSz) {
     49   BufferIO->File = File;
     50   BufferIO->FileWriter = FileWriter;
     51   BufferIO->BufferStart = Buffer;
     52   BufferIO->BufferSz = BufferSz;
     53   BufferIO->CurOffset = 0;
     54 }
     55 
     56 COMPILER_RT_VISIBILITY ProfBufferIO *
     57 lprofCreateBufferIO(WriterCallback FileWriter, void *File) {
     58   uint8_t *Buffer = DynamicBufferIOBuffer;
     59   uint32_t BufferSize = VPBufferSize;
     60   if (!Buffer) {
     61     Buffer = &BufferIOBuffer[0];
     62     BufferSize = sizeof(BufferIOBuffer);
     63   }
     64   llvmInitBufferIO(&TheBufferIO, FileWriter, File, Buffer, BufferSize);
     65   return &TheBufferIO;
     66 }
     67 
     68 COMPILER_RT_VISIBILITY void lprofDeleteBufferIO(ProfBufferIO *BufferIO) {
     69   if (DynamicBufferIOBuffer) {
     70     FreeHook(DynamicBufferIOBuffer);
     71     DynamicBufferIOBuffer = 0;
     72     VPBufferSize = 0;
     73   }
     74 }
     75 
     76 COMPILER_RT_VISIBILITY int
     77 lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data, uint32_t Size) {
     78   /* Buffer is not large enough, it is time to flush.  */
     79   if (Size + BufferIO->CurOffset > BufferIO->BufferSz) {
     80     if (lprofBufferIOFlush(BufferIO) != 0)
     81       return -1;
     82   }
     83   /* Special case, bypass the buffer completely. */
     84   ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size}};
     85   if (Size > BufferIO->BufferSz) {
     86     if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
     87       return -1;
     88   } else {
     89     /* Write the data to buffer */
     90     uint8_t *Buffer = BufferIO->BufferStart + BufferIO->CurOffset;
     91     lprofBufferWriter(IO, 1, (void **)&Buffer);
     92     BufferIO->CurOffset = Buffer - BufferIO->BufferStart;
     93   }
     94   return 0;
     95 }
     96 
     97 COMPILER_RT_VISIBILITY int lprofBufferIOFlush(ProfBufferIO *BufferIO) {
     98   if (BufferIO->CurOffset) {
     99     ProfDataIOVec IO[] = {
    100         {BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset}};
    101     if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
    102       return -1;
    103     BufferIO->CurOffset = 0;
    104   }
    105   return 0;
    106 }
    107 
    108 /* Write out value profile data for function specified with \c Data.
    109  * The implementation does not use the method \c serializeValueProfData
    110  * which depends on dynamic memory allocation. In this implementation,
    111  * value profile data is written out to \c BufferIO piecemeal.
    112  */
    113 static int writeOneValueProfData(ProfBufferIO *BufferIO,
    114                                  VPDataReaderType *VPDataReader,
    115                                  const __llvm_profile_data *Data) {
    116   unsigned I, NumValueKinds = 0;
    117   ValueProfData VPHeader;
    118   uint8_t *SiteCountArray[IPVK_Last + 1];
    119 
    120   for (I = 0; I <= IPVK_Last; I++) {
    121     if (!Data->NumValueSites[I])
    122       SiteCountArray[I] = 0;
    123     else {
    124       uint32_t Sz =
    125           VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
    126           offsetof(ValueProfRecord, SiteCountArray);
    127       /* Only use alloca for this small byte array to avoid excessive
    128        * stack growth.  */
    129       SiteCountArray[I] = (uint8_t *)COMPILER_RT_ALLOCA(Sz);
    130       memset(SiteCountArray[I], 0, Sz);
    131     }
    132   }
    133 
    134   /* If NumValueKinds returned is 0, there is nothing to write, report
    135      success and return. This should match the raw profile reader's behavior. */
    136   if (!(NumValueKinds = VPDataReader->InitRTRecord(Data, SiteCountArray)))
    137     return 0;
    138 
    139   /* First write the header structure. */
    140   VPHeader.TotalSize = VPDataReader->GetValueProfDataSize();
    141   VPHeader.NumValueKinds = NumValueKinds;
    142   if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPHeader,
    143                          sizeof(ValueProfData)))
    144     return -1;
    145 
    146   /* Make sure nothing else needs to be written before value profile
    147    * records. */
    148   if ((void *)VPDataReader->GetFirstValueProfRecord(&VPHeader) !=
    149       (void *)(&VPHeader + 1))
    150     return -1;
    151 
    152   /* Write out the value profile record for each value kind
    153    * one by one. */
    154   for (I = 0; I <= IPVK_Last; I++) {
    155     uint32_t J;
    156     ValueProfRecord RecordHeader;
    157     /* The size of the value prof record header without counting the
    158      * site count array .*/
    159     uint32_t RecordHeaderSize = offsetof(ValueProfRecord, SiteCountArray);
    160     uint32_t SiteCountArraySize;
    161 
    162     if (!Data->NumValueSites[I])
    163       continue;
    164 
    165     /* Write out the record header.  */
    166     RecordHeader.Kind = I;
    167     RecordHeader.NumValueSites = Data->NumValueSites[I];
    168     if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&RecordHeader,
    169                            RecordHeaderSize))
    170       return -1;
    171 
    172     /* Write out the site value count array including padding space. */
    173     SiteCountArraySize =
    174         VPDataReader->GetValueProfRecordHeaderSize(Data->NumValueSites[I]) -
    175         RecordHeaderSize;
    176     if (lprofBufferIOWrite(BufferIO, SiteCountArray[I], SiteCountArraySize))
    177       return -1;
    178 
    179     /* Write out the value profile data for each value site.  */
    180     for (J = 0; J < Data->NumValueSites[I]; J++) {
    181       uint32_t NRead, NRemain;
    182       ValueProfNode *NextStartNode = 0;
    183       NRemain = VPDataReader->GetNumValueDataForSite(I, J);
    184       if (!NRemain)
    185         continue;
    186       /* Read and write out value data in small chunks till it is done. */
    187       do {
    188         NRead = (NRemain > VPDataArraySize ? VPDataArraySize : NRemain);
    189         NextStartNode =
    190             VPDataReader->GetValueData(I, /* ValueKind */
    191                                        J, /* Site */
    192                                        &VPDataArray[0], NextStartNode, NRead);
    193         if (lprofBufferIOWrite(BufferIO, (const uint8_t *)&VPDataArray[0],
    194                                NRead * sizeof(InstrProfValueData)))
    195           return -1;
    196         NRemain -= NRead;
    197       } while (NRemain != 0);
    198     }
    199   }
    200   /* All done report success.  */
    201   return 0;
    202 }
    203 
    204 static int writeValueProfData(WriterCallback Writer, void *WriterCtx,
    205                               VPDataReaderType *VPDataReader,
    206                               const __llvm_profile_data *DataBegin,
    207                               const __llvm_profile_data *DataEnd) {
    208   ProfBufferIO *BufferIO;
    209   const __llvm_profile_data *DI = 0;
    210 
    211   if (!VPDataReader)
    212     return 0;
    213 
    214   BufferIO = lprofCreateBufferIO(Writer, WriterCtx);
    215 
    216   for (DI = DataBegin; DI < DataEnd; DI++) {
    217     if (writeOneValueProfData(BufferIO, VPDataReader, DI))
    218       return -1;
    219   }
    220 
    221   if (lprofBufferIOFlush(BufferIO) != 0)
    222     return -1;
    223   lprofDeleteBufferIO(BufferIO);
    224 
    225   return 0;
    226 }
    227 
    228 COMPILER_RT_VISIBILITY int lprofWriteData(WriterCallback Writer,
    229                                           void *WriterCtx,
    230                                           VPDataReaderType *VPDataReader) {
    231   /* Match logic in __llvm_profile_write_buffer(). */
    232   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
    233   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
    234   const uint64_t *CountersBegin = __llvm_profile_begin_counters();
    235   const uint64_t *CountersEnd = __llvm_profile_end_counters();
    236   const char *NamesBegin = __llvm_profile_begin_names();
    237   const char *NamesEnd = __llvm_profile_end_names();
    238   return lprofWriteDataImpl(Writer, WriterCtx, DataBegin, DataEnd,
    239                             CountersBegin, CountersEnd, VPDataReader,
    240                             NamesBegin, NamesEnd);
    241 }
    242 
    243 COMPILER_RT_VISIBILITY int
    244 lprofWriteDataImpl(WriterCallback Writer, void *WriterCtx,
    245                    const __llvm_profile_data *DataBegin,
    246                    const __llvm_profile_data *DataEnd,
    247                    const uint64_t *CountersBegin, const uint64_t *CountersEnd,
    248                    VPDataReaderType *VPDataReader, const char *NamesBegin,
    249                    const char *NamesEnd) {
    250 
    251   /* Calculate size of sections. */
    252   const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
    253   const uint64_t CountersSize = CountersEnd - CountersBegin;
    254   const uint64_t NamesSize = NamesEnd - NamesBegin;
    255   const uint64_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);
    256 
    257   /* Enough zeroes for padding. */
    258   const char Zeroes[sizeof(uint64_t)] = {0};
    259 
    260   /* Create the header. */
    261   __llvm_profile_header Header;
    262 
    263   if (!DataSize)
    264     return 0;
    265 
    266 /* Initialize header structure.  */
    267 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
    268 #include "InstrProfData.inc"
    269 
    270   /* Write the data. */
    271   ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1},
    272                            {DataBegin, sizeof(__llvm_profile_data), DataSize},
    273                            {CountersBegin, sizeof(uint64_t), CountersSize},
    274                            {NamesBegin, sizeof(uint8_t), NamesSize},
    275                            {Zeroes, sizeof(uint8_t), Padding}};
    276   if (Writer(IOVec, sizeof(IOVec) / sizeof(*IOVec), &WriterCtx))
    277     return -1;
    278 
    279   return writeValueProfData(Writer, WriterCtx, VPDataReader, DataBegin,
    280                             DataEnd);
    281 }
    282