[XRay][compiler-rt] Profiling Mode: Include file header in buffers

[dberris]

Summary

This change provides access to the file header even in the in-memory
buffer processing. This allows in-memory processing of the buffers to
also check the version, and the format, of the profile data.

[dberris]

fix typo.

[dberris]

fix another typo.

[dberris]

Use u64 more consistently instead of uptr.

compiler-rt/trunk/lib/xray/tests/unit/profile_collector_test.cc

 // This file is a part of XRay, a function call tracing system.
 //
 //===----------------------------------------------------------------------===//
 #include "gtest/gtest.h"
 
 #include "xray_profile_collector.h"
 #include "xray_profiling_flags.h"
 #include <cstdint>
+#include <cstring>
+#include <memory>
 #include <thread>
 #include <utility>
 #include <vector>
 
 namespace __xray {
 namespace {
 
 static constexpr auto kHeaderSize = 16u;
 
+constexpr uptr ExpectedProfilingVersion = 0x20180424;
+
+struct ExpectedProfilingFileHeader {
+  const u64 MagicBytes = 0x7872617970726f66; // Identifier for XRay profiling
+                                             // files 'xrayprof' in hex.
+  const uptr Version = ExpectedProfilingVersion;
+  uptr Timestamp = 0;
+  uptr PID = 0;
+};
+
+void ValidateFileHeaderBlock(XRayBuffer B) {
+  ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
+  ASSERT_EQ(B.Size, sizeof(ExpectedProfilingFileHeader));
+  typename std::aligned_storage<sizeof(ExpectedProfilingFileHeader)>::type
+      FileHeaderStorage;
+  ExpectedProfilingFileHeader ExpectedHeader;
+  std::memcpy(&FileHeaderStorage, B.Data, B.Size);
+  auto &FileHeader =
+      *reinterpret_cast<ExpectedProfilingFileHeader *>(&FileHeaderStorage);
+  ASSERT_EQ(ExpectedHeader.MagicBytes, FileHeader.MagicBytes);
+  ASSERT_EQ(ExpectedHeader.Version, FileHeader.Version);
+}
+
 void ValidateBlock(XRayBuffer B) {
   profilingFlags()->setDefaults();
   ASSERT_NE(static_cast<const void *>(B.Data), nullptr);
   ASSERT_NE(B.Size, 0u);
   ASSERT_GE(B.Size, kHeaderSize);
   // We look at the block size, the block number, and the thread ID to ensure
   // that none of them are zero (or that the header data is laid out as we
   // expect).
TEST(profileCollectorServiceTest, PostSerializeCollect) {
   T.exitFunction(1, 4);
 
   // Then we post the data to the global profile collector service.
   profileCollectorService::post(T, 1);
 
   // Then we serialize the data.
   profileCollectorService::serialize();
 
-  // Then we go through a single buffer to see whether we're getting the data we
-  // expect.
+  // Then we go through two buffers to see whether we're getting the data we
+  // expect. The first block must always be as large as a file header, which
+  // will have a fixed size.
   auto B = profileCollectorService::nextBuffer({nullptr, 0});
+  ValidateFileHeaderBlock(B);
+
+  B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);
   u32 BlockSize;
   u32 BlockNum;
   u64 ThreadId;
   std::tie(BlockSize, BlockNum, ThreadId) = ParseBlockHeader(B);
 
   // We look at the serialized buffer to see whether the Trie we're expecting
   // to see is there.
TEST(profileCollectorServiceTest, PostSerializeCollectMultipleThread) {
   t1.join();
   t2.join();
 
   // At this point, t1 and t2 are already done with what they were doing.
   profileCollectorService::serialize();
 
   // Ensure that we see two buffers.
   auto B = profileCollectorService::nextBuffer({nullptr, 0});
+  ValidateFileHeaderBlock(B);
+
+  B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);
 
   B = profileCollectorService::nextBuffer(B);
   ValidateBlock(B);
 }
 
 } // namespace
 } // namespace __xray

compiler-rt/trunk/lib/xray/xray_profile_collector.cc

struct ThreadTrie {
   FunctionCallTrie *Trie;
 };
 
 struct ProfileBuffer {
   void *Data;
   size_t Size;
 };
 
+// Current version of the profile format.
+constexpr u64 XRayProfilingVersion = 0x20180424;
+
+// Identifier for XRay profiling files 'xrayprof' in hex.
+constexpr u64 XRayMagicBytes = 0x7872617970726f66;
+
+struct XRayProfilingFileHeader {
+  const u64 MagicBytes = XRayMagicBytes;
+  const u64 Version = XRayProfilingVersion;
+  u64 Timestamp = 0; // System time in nanoseconds.
+  u64 PID = 0;       // Process ID.
+};
+
 struct BlockHeader {
   u32 BlockSize;
   u32 BlockNum;
   u64 ThreadId;
 };
 
 // These need to be pointers that point to heap/internal-allocator-allocated
 // objects because these are accessed even at program exit.

 }
 
 XRayBuffer nextBuffer(XRayBuffer B) {
   SpinMutexLock Lock(&GlobalMutex);
 
   if (ProfileBuffers == nullptr || ProfileBuffers->Size() == 0)
     return {nullptr, 0};
 
-  if (B.Data == nullptr)
+  static pthread_once_t Once = PTHREAD_ONCE_INIT;
+  static typename std::aligned_storage<sizeof(XRayProfilingFileHeader)>::type
+      FileHeaderStorage;
+  pthread_once(&Once,
+               +[] { new (&FileHeaderStorage) XRayProfilingFileHeader{}; });
+
+  if (UNLIKELY(B.Data == nullptr)) {
+    // The first buffer should always contain the file header information.
+    auto &FileHeader =
+        *reinterpret_cast<XRayProfilingFileHeader *>(&FileHeaderStorage);
+    FileHeader.Timestamp = NanoTime();
+    FileHeader.PID = internal_getpid();
+    return {&FileHeaderStorage, sizeof(XRayProfilingFileHeader)};
+  }
+
+  if (UNLIKELY(B.Data == &FileHeaderStorage))
     return {(*ProfileBuffers)[0].Data, (*ProfileBuffers)[0].Size};
 
   BlockHeader Header;
   internal_memcpy(&Header, B.Data, sizeof(BlockHeader));
   auto NextBlock = Header.BlockNum + 1;
   if (NextBlock < ProfileBuffers->Size())
     return {(*ProfileBuffers)[NextBlock].Data,
             (*ProfileBuffers)[NextBlock].Size};
   return {nullptr, 0};
 }
 
 } // namespace profileCollectorService
 } // namespace __xray

compiler-rt/trunk/lib/xray/xray_profiling.cc

 #include "xray_tsc.h"
 #include "xray_utils.h"
 #include <pthread.h>
 
 namespace __xray {
 
 namespace {
 
-constexpr uptr XRayProfilingVersion = 0x20180424;
-
-struct XRayProfilingFileHeader {
-  const u64 MagicBytes = 0x7872617970726f66; // Identifier for XRay profiling
-                                             // files 'xrayprof' in hex.
-  const uptr Version = XRayProfilingVersion;
-  uptr Timestamp = 0; // System time in nanoseconds.
-  uptr PID = 0;       // Process ID.
-};
-
 atomic_sint32_t ProfilerLogFlushStatus = {
     XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING};
 
 atomic_sint32_t ProfilerLogStatus = {XRayLogInitStatus::XRAY_LOG_UNINITIALIZED};
 
 SpinMutex ProfilerOptionsMutex;
 
 struct alignas(64) ProfilingData {
if (B.Data == nullptr) {
       if (Verbosity())
         Report("profiling: No data to flush.\n");
     } else {
       int Fd = getLogFD();
       if (Fd == -1) {
         if (Verbosity())
           Report("profiling: Failed to flush to file, dropping data.\n");
       } else {
-        XRayProfilingFileHeader Header;
-        Header.Timestamp = NanoTime();
-        Header.PID = internal_getpid();
-        retryingWriteAll(Fd, reinterpret_cast<const char *>(&Header),
-                         reinterpret_cast<const char *>(&Header) +
-                             sizeof(Header));
-
-        // Now for each of the threads, write out the profile data as we would
+        // Now for each of the buffers, write out the profile data as we would
         // see it in memory, verbatim.
         while (B.Data != nullptr && B.Size != 0) {
           retryingWriteAll(Fd, reinterpret_cast<const char *>(B.Data),
                            reinterpret_cast<const char *>(B.Data) + B.Size);
           B = profileCollectorService::nextBuffer(B);
         }
         // Then we close out the file.
         internal_close(Fd);

compiler-rt/trunk/test/xray/TestCases/Posix/profiling-multi-threaded.cc

[[clang::xray_always_instrument]] int main(int, char **) {
   std::thread t0([] { f0(); });
   std::thread t1([] { f0(); });
   f0();
   t0.join();
   t1.join();
   assert(__xray_log_finalize() == XRayLogInitStatus::XRAY_LOG_FINALIZED);
   assert(__xray_log_process_buffers(process_buffer) ==
          XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-  // We're running three threds, so we expect three buffers.
-  assert(buffer_counter == 3);
+  // We're running three threads, so we expect four buffers (including the file
+  // header buffer).
+  assert(buffer_counter == 4);
   assert(__xray_log_flushLog() == XRayLogFlushStatus::XRAY_LOG_FLUSHED);
 }

compiler-rt/trunk/test/xray/TestCases/Posix/profiling-single-threaded.cc

[[clang::xray_always_instrument]] int main(int, char **) {
   assert(__xray_patch() == XRayPatchingStatus::SUCCESS);
   assert(__xray_log_init_mode("xray-profiling", "") ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED);
   f0();
   assert(__xray_log_finalize() == XRayLogInitStatus::XRAY_LOG_FINALIZED);
   f0();
   assert(__xray_log_process_buffers(process_buffer) ==
          XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-  assert(buffer_counter == 1);
+  // There's always at least one buffer, containing the profile file header. We
+  // assert that we have two, to indicate that we're expecting exactly one
+  // thread's worth of data.
+  assert(buffer_counter == 2);
   assert(__xray_log_flushLog() == XRayLogFlushStatus::XRAY_LOG_FLUSHED);
 
   // Let's reset the counter.
   buffer_counter = 0;
 
   assert(__xray_log_init_mode("xray-profiling", "") ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED);
   f0();
   assert(__xray_log_finalize() == XRayLogInitStatus::XRAY_LOG_FINALIZED);
   f0();
   assert(__xray_log_process_buffers(process_buffer) ==
          XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-  assert(buffer_counter == 1);
+  assert(buffer_counter == 2);
   assert(__xray_log_flushLog() == XRayLogFlushStatus::XRAY_LOG_FLUSHED);
 }