[profile] Avoid allocating a page on the stack, NFC

[vsk]

Summary

When writing out a profile, avoid allocating a page on the stack for the
purpose of writing out zeroes, as some embedded environments do not have
enough stack space to accomodate this.

Instead, use a small, fixed-size zero buffer that can be written
repeatedly.

For a synthetic file with >100,000 functions, I did not measure a
significant difference in profile write times. We are removing a
page-length zero-fill memset() in favor of several smaller buffered
fwrite() calls: in practice, I am not sure there is much of a
difference. The performance impact is only expected to affect the
continuous sync mode (%c) -- zero padding is less than 8 bytes in all
other cases.

rdar://57810014

[davidxl]

lgtm

[MaskRay]

compiler-rt/lib/profile/InstrProfilingFile.c

136

sizeof(uint8_t) -> 1 ?

[vsk]

Thanks for the reviews!

compiler-rt/lib/profile/InstrProfilingFile.c

136

That's a reasonable alternative. However the current convention in libprofile is to write out the sizeof.

compiler-rt/lib/profile/InstrProfilingFile.c

static unsigned doMerging() {
   return lprofCurFilename.MergePoolSize || isProfileMergeRequested();
 }
 
 /* Return 1 if there is an error, otherwise return  0.  */
 static uint32_t fileWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
                            uint32_t NumIOVecs) {
   uint32_t I;
   FILE *File = (FILE *)This->WriterCtx;
+  char Zeroes[sizeof(uint64_t)] = {0};
   for (I = 0; I < NumIOVecs; I++) {
     if (IOVecs[I].Data) {
       if (fwrite(IOVecs[I].Data, IOVecs[I].ElmSize, IOVecs[I].NumElm, File) !=
           IOVecs[I].NumElm)
         return 1;
+    } else if (IOVecs[I].UseZeroPadding) {
+      size_t BytesToWrite = IOVecs[I].ElmSize * IOVecs[I].NumElm;
+      while (BytesToWrite > 0) {
+        size_t PartialWriteLen =
+            (sizeof(uint64_t) > BytesToWrite) ? BytesToWrite : sizeof(uint64_t);
+        if (fwrite(Zeroes, sizeof(uint8_t), PartialWriteLen, File) !=
+            PartialWriteLen) {
+          return 1;
+        }
+        BytesToWrite -= PartialWriteLen;
+      }
     } else {
       if (fseek(File, IOVecs[I].ElmSize * IOVecs[I].NumElm, SEEK_CUR) == -1)
         return 1;
     }
   }
   return 0;
 }
 

compiler-rt/lib/profile/InstrProfilingInternal.h

 int __llvm_profile_write_buffer_internal(
     char *Buffer, const __llvm_profile_data *DataBegin,
     const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
     const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd);
 
 /*!
  * The data structure describing the data to be written by the
  * low level writer callback function.
+ *
+ * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
+ * 0, the write is skipped (the writer simply advances ElmSize*NumElm bytes).
+ *
+ * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
+ * nonzero, ElmSize*NumElm zero bytes are written.
  */
 typedef struct ProfDataIOVec {
   const void *Data;
   size_t ElmSize;
   size_t NumElm;
+  int UseZeroPadding;
 } ProfDataIOVec;
 
 struct ProfDataWriter;
 typedef uint32_t (*WriterCallback)(struct ProfDataWriter *This, ProfDataIOVec *,
                                    uint32_t NumIOVecs);
 
 typedef struct ProfDataWriter {
   WriterCallback Write;

compiler-rt/lib/profile/InstrProfilingPlatformFuchsia.c

static uint32_t lprofVMOWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
   /* Copy the data into VMO. */
   for (uint32_t I = 0; I < NumIOVecs; I++) {
     size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
     if (IOVecs[I].Data) {
       Status = _zx_vmo_write(__llvm_profile_vmo, IOVecs[I].Data,
                              __llvm_profile_offset, Length);
       if (Status != ZX_OK)
         return -1;
+    } else if (IOVecs[I].UseZeroPadding) {
+      /* Resizing the VMO should zero fill. */
     }
     __llvm_profile_offset += Length;
   }
 
   return 0;
 }
 
 static void initVMOWriter(ProfDataWriter *This) {

compiler-rt/lib/profile/InstrProfilingWriter.c

COMPILER_RT_VISIBILITY uint32_t lprofBufferWriter(ProfDataWriter *This,
                                                   ProfDataIOVec *IOVecs,
                                                   uint32_t NumIOVecs) {
   uint32_t I;
   char **Buffer = (char **)&This->WriterCtx;
   for (I = 0; I < NumIOVecs; I++) {
     size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
     if (IOVecs[I].Data)
       memcpy(*Buffer, IOVecs[I].Data, Length);
+    else if (IOVecs[I].UseZeroPadding) {
+      /* Allocating the buffer should zero fill. */
+    }
     *Buffer += Length;
   }
   return 0;
 }
 
 static void llvmInitBufferIO(ProfBufferIO *BufferIO, ProfDataWriter *FileWriter,
                              uint8_t *Buffer, uint32_t BufferSz) {
   BufferIO->FileWriter = FileWriter;

 COMPILER_RT_VISIBILITY int
 lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data, uint32_t Size) {
   /* Buffer is not large enough, it is time to flush.  */
   if (Size + BufferIO->CurOffset > BufferIO->BufferSz) {
     if (lprofBufferIOFlush(BufferIO) != 0)
       return -1;
   }
   /* Special case, bypass the buffer completely. */
-  ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size}};
+  ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size, 0}};
   if (Size > BufferIO->BufferSz) {
     if (BufferIO->FileWriter->Write(BufferIO->FileWriter, IO, 1))
       return -1;
   } else {
     /* Write the data to buffer */
     uint8_t *Buffer = BufferIO->BufferStart + BufferIO->CurOffset;
     ProfDataWriter BufferWriter;
     initBufferWriter(&BufferWriter, (char *)Buffer);
     lprofBufferWriter(&BufferWriter, IO, 1);
     BufferIO->CurOffset =
         (uint8_t *)BufferWriter.WriterCtx - BufferIO->BufferStart;
   }
   return 0;
 }
 
 COMPILER_RT_VISIBILITY int lprofBufferIOFlush(ProfBufferIO *BufferIO) {
   if (BufferIO->CurOffset) {
     ProfDataIOVec IO[] = {
-        {BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset}};
+        {BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset, 0}};
     if (BufferIO->FileWriter->Write(BufferIO->FileWriter, IO, 1))
       return -1;
     BufferIO->CurOffset = 0;
   }
   return 0;
 }
 
 /* Write out value profile data for function specified with \c Data.
lprofWriteDataImpl(ProfDataWriter *Writer, const __llvm_profile_data *DataBegin,
                    VPDataReaderType *VPDataReader, const char *NamesBegin,
                    const char *NamesEnd, int SkipNameDataWrite) {
 
   /* Calculate size of sections. */
   const uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
   const uint64_t CountersSize = CountersEnd - CountersBegin;
   const uint64_t NamesSize = NamesEnd - NamesBegin;
 
-  /* Enough zeroes for padding. */
-  unsigned PageSize = getpagesize();
-  char *Zeroes = (char *)COMPILER_RT_ALLOCA(PageSize);
-  memset(Zeroes, 0, PageSize);
-
   /* Create the header. */
   __llvm_profile_header Header;
 
   if (!DataSize)
     return 0;
 
   /* Determine how much padding is needed before/after the counters and after
    * the names. */
   uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
       PaddingBytesAfterNames;
   __llvm_profile_get_padding_sizes_for_counters(
       DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters,
       &PaddingBytesAfterCounters, &PaddingBytesAfterNames);
 
 /* Initialize header structure.  */
 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
 #include "profile/InstrProfData.inc"
 
   /* Write the data. */
   ProfDataIOVec IOVec[] = {
-      {&Header, sizeof(__llvm_profile_header), 1},
-      {DataBegin, sizeof(__llvm_profile_data), DataSize},
-      {Zeroes, sizeof(uint8_t), PaddingBytesBeforeCounters},
-      {CountersBegin, sizeof(uint64_t), CountersSize},
-      {Zeroes, sizeof(uint8_t), PaddingBytesAfterCounters},
-      {SkipNameDataWrite ? NULL : NamesBegin, sizeof(uint8_t), NamesSize},
-      {Zeroes, sizeof(uint8_t), PaddingBytesAfterNames}};
+      {&Header, sizeof(__llvm_profile_header), 1, 0},
+      {DataBegin, sizeof(__llvm_profile_data), DataSize, 0},
+      {NULL, sizeof(uint8_t), PaddingBytesBeforeCounters, 1},
+      {CountersBegin, sizeof(uint64_t), CountersSize, 0},
+      {NULL, sizeof(uint8_t), PaddingBytesAfterCounters, 1},
+      {SkipNameDataWrite ? NULL : NamesBegin, sizeof(uint8_t), NamesSize, 0},
+      {NULL, sizeof(uint8_t), PaddingBytesAfterNames, 1}};
   if (Writer->Write(Writer, IOVec, sizeof(IOVec) / sizeof(*IOVec)))
     return -1;
 
   /* Value profiling is not yet supported in continuous mode. */
   if (__llvm_profile_is_continuous_mode_enabled())
     return 0;
 
   return writeValueProfData(Writer, VPDataReader, DataBegin, DataEnd);
 }