[XRay] Remove the deprecated __xray_log_init API

[phosek]

Summary

This API has been deprecated three months ago and shouldn't be used
anymore, all clients should migrate to the new string based API.

[dberris]

compiler-rt/include/xray/xray_log_interface.h

173 ↗

(On Diff #163753)

This is an API+ABI change which we haven't communicated yet to users.

Please leave the interface as-is, update the comment that the first two arguments are no longer needed, and keep everything else as-is. We can tackle changing this at a later time, when we've had a chance to implement a replacement API to let users migrate to instead.

[phosek]

compiler-rt/include/xray/xray_log_interface.h

173 ↗

(On Diff #163753)

Shall I keep FDRLoggingOptions and BasicLoggingOptions structs around as well or is it fine to remove those?

[dberris]

compiler-rt/include/xray/xray_log_interface.h

173 ↗

(On Diff #163753)

Please remove those along with __xray_log_init(...). Thanks!

[dberris]

LGTM -- Thanks, @phosek!

[vsapsai]

Who is responsible for updating the clients? Currently in the test suite MicroBenchmarks/XRay/FDRMode/fdrmode-bench.cc is failing to compile because [it is using __xray::FDRLoggingOptions](https://github.com/llvm-mirror/test-suite/blob/75acfc14c04d4d95c42b7f6dcd44d3e4ac6b5270/MicroBenchmarks/XRay/FDRMode/fdrmode-bench.cc#L29).

Can you please fix fdrmode-bench.cc to use correct API? Or if it is going to take a lot of time, revert this change?

[dberris]

In D51606#1237514, @vsapsai wrote:

Who is responsible for updating the clients? Currently in the test suite MicroBenchmarks/XRay/FDRMode/fdrmode-bench.cc is failing to compile because [it is using __xray::FDRLoggingOptions](https://github.com/llvm-mirror/test-suite/blob/75acfc14c04d4d95c42b7f6dcd44d3e4ac6b5270/MicroBenchmarks/XRay/FDRMode/fdrmode-bench.cc#L29).

Can you please fix fdrmode-bench.cc to use correct API? Or if it is going to take a lot of time, revert this change?

Good point -- yes, I'll work on changing the test-suite benchmarks, I can do that quickly.

[dberris]

test-suite should be fixed by r342426.

[vsapsai]

In D51606#1237549, @dberris wrote:

test-suite should be fixed by r342426.

Thanks for the fix, Dean. There are still some issues remaining. Jobs

• http://green.lab.llvm.org/green/job/lnt-test-suite-x86_64-O3-flto/
• http://green.lab.llvm.org/green/job/lnt-test-suite-x86_64-Os-flto/

are still failing for the test test-suite :: MicroBenchmarks/XRay/FDRMode/fdrmode-bench.test. According to my understanding the built binary fdrmode-bench is crashing:

******************** TEST 'test-suite :: MicroBenchmarks/XRay/FDRMode/fdrmode-bench.test' FAILED ********************

/Users/buildslave/jenkins/workspace/lnt-test-suite-x86_64-Os-flto/lnt-sandbox/build/MicroBenchmarks/XRay/FDRMode/fdrmode-bench --benchmark_format=csv > /Users/buildslave/jenkins/workspace/lnt-test-suite-x86_64-Os-flto/lnt-sandbox/build/MicroBenchmarks/XRay/FDRMode/Output/fdrmode-bench.test.bench.csv

Run on (8 X 2600 MHz CPU s)
2018-09-18 11:14:39
/Users/buildslave/jenkins/workspace/lnt-test-suite-x86_64-Os-flto/lnt-sandbox/build/MicroBenchmarks/XRay/FDRMode/Output/fdrmode-bench.test_run.script: line 1: 86215 Abort trap: 6           /Users/buildslave/jenkins/workspace/lnt-test-suite-x86_64-Os-flto/lnt-sandbox/build/MicroBenchmarks/XRay/FDRMode/fdrmode-bench --benchmark_format=csv > /Users/buildslave/jenkins/workspace/lnt-test-suite-x86_64-Os-flto/lnt-sandbox/build/MicroBenchmarks/XRay/FDRMode/Output/fdrmode-bench.test.bench.csv

********************

Can you or somebody else knowledgeable in XRay please take a look?

[dberris]

Is this on Darwin? If it is, then @devnexen has been the one working on making that work. I'm not sure whether there's a way to exclude the XRay test from macOS/Darwin, but the most prudent thing should be to disable it there until the Darwin support is properly fixed.

Do you have a way of reproducing these in isolation? I'm not familiar enough with Jenkins to figure this one out on my own. :(

[vsapsai]

I have published D52278 for disabling the test on Darwin. So far my investigation shows that __xray_log_select_mode("xray-fdr") returns 2 (aka XRAY_MODE_NOT_FOUND) and that's why we are calling std::abort.

if (__xray_log_select_mode("xray-fdr") !=
    XRayLogRegisterStatus::XRAY_REGISTRATION_OK)
  std::abort();

Any advices on how to troubleshoot this situation? I tried XRAY_OPTIONS="verbosity=1" and XRAY_FDR_OPTIONS="verbosity=1" but there is no extra logging. I am using clang version 8.0.0 (trunk 342513) and it has libclang_rt.xray-basic_osx.a, libclang_rt.xray-fdr_osx.a, libclang_rt.xray-profiling_osx.a, libclang_rt.xray_osx.a.

I have a smallish repro but I need to clean it up. Writing this I realized that in that repro we are using pieces of host compiler, not compiler-under-test (-isysroot, -B). Depending on the time FDR mode was added, host compiler might not have support for it.

[dberris]

In D51606#1239847, @vsapsai wrote:

I have published D52278 for disabling the test on Darwin. So far my investigation shows that __xray_log_select_mode("xray-fdr") returns 2 (aka XRAY_MODE_NOT_FOUND) and that's why we are calling std::abort.

if (__xray_log_select_mode("xray-fdr") !=
    XRayLogRegisterStatus::XRAY_REGISTRATION_OK)
  std::abort();

Any advices on how to troubleshoot this situation? I tried XRAY_OPTIONS="verbosity=1" and XRAY_FDR_OPTIONS="verbosity=1" but there is no extra logging. I am using clang version 8.0.0 (trunk 342513) and it has libclang_rt.xray-basic_osx.a, libclang_rt.xray-fdr_osx.a, libclang_rt.xray-profiling_osx.a, libclang_rt.xray_osx.a.

There won't be much to log if we don't find the mode available for selection, unfortunately.

I have a smallish repro but I need to clean it up. Writing this I realized that in that repro we are using pieces of host compiler, not compiler-under-test (-isysroot, -B). Depending on the time FDR mode was added, host compiler might not have support for it.

That would do it.

I don't know whether @devnexen has done any testing with the test-suite, but I'm confident that at least the compiler-rt tests for XRay don't get run on macOS yet. There was some effort to make that work and be properly supported but that work has stalled and I've not gotten back to it myself.

[vsapsai]

The repro is

// $COMPILER_DIR/bin/clang++ -O0 -arch x86_64 -Wl,-search_paths_first -Wl,-headerpad_max_install_names  main.cpp  -o a.out -Wl,-no_pie -fxray-instrument
//
// or
//
// $COMPILER_DIR/bin/clang++ main.cpp -o a.out -fxray-instrument

#include "xray/xray_log_interface.h"

int main(int argc, char *argv[]) {
    XRayLogRegisterStatus status = __xray_log_select_mode("xray-fdr");
    return status;
}

I checked that we link with correct libraries, so seems like XRay currently is just not working on macOS.

compiler-rt/trunk/include/xray/xray_log_interface.h

 
 /// A valid XRay logging implementation MUST provide all of the function
 /// pointers in XRayLogImpl when being installed through `__xray_set_log_impl`.
 /// To be precise, ALL the functions pointers MUST NOT be nullptr.
 struct XRayLogImpl {
   /// The log initialization routine provided by the implementation, always
   /// provided with the following parameters:
   ///
-  ///   - buffer size
-  ///   - maximum number of buffers
+  ///   - buffer size (unused)
+  ///   - maximum number of buffers (unused)
   ///   - a pointer to an argument struct that the implementation MUST handle
   ///   - the size of the argument struct
   ///
   /// See XRayLogInitStatus for details on what the implementation MUST return
   /// when called.
   ///
   /// If the implementation needs to install handlers aside from the 0-argument
   /// function call handler, it MUST do so in this initialization handler.

 ///
 /// See XRayLogFlushStatus for what the return values mean.
 ///
 XRayLogFlushStatus __xray_log_process_buffers(void (*Processor)(const char *,
                                                                 XRayBuffer));
 
 } // extern "C"
 
-namespace __xray {
-
-/// DEPRECATED: Use __xray_log_init_mode(...) instead, and provide flag
-/// configuration strings to set the options instead.
-/// Options used by the LLVM XRay FDR logging implementation.
-struct FDRLoggingOptions {
-  bool ReportErrors = false;
-  int Fd = -1;
-};
-
-/// DEPRECATED: Use __xray_log_init_mode(...) instead, and provide flag
-/// configuration strings to set the options instead.
-/// Options used by the LLVM XRay Basic (Naive) logging implementation.
-struct BasicLoggingOptions {
-  int DurationFilterMicros = 0;
-  size_t MaxStackDepth = 0;
-  size_t ThreadBufferSize = 0;
-};
-
-} // namespace __xray
-
 #endif // XRAY_XRAY_LOG_INTERFACE_H

compiler-rt/trunk/lib/xray/tests/unit/CMakeLists.txt

 add_xray_unittest(XRayBufferQueueTest SOURCES
   buffer_queue_test.cc xray_unit_test_main.cc)
-add_xray_unittest(XRayFDRLoggingTest SOURCES
-  fdr_logging_test.cc xray_unit_test_main.cc)
 add_xray_unittest(XRayAllocatorTest SOURCES
   allocator_test.cc xray_unit_test_main.cc)
 add_xray_unittest(XRaySegmentedArrayTest SOURCES
   segmented_array_test.cc xray_unit_test_main.cc)
 add_xray_unittest(XRayFunctionCallTrieTest SOURCES
   function_call_trie_test.cc xray_unit_test_main.cc)
 add_xray_unittest(XRayProfileCollectorTest SOURCES
   profile_collector_test.cc xray_unit_test_main.cc)

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

-//===-- fdr_logging_test.cc -----------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is a part of XRay, a function call tracing system.
-//
-//===----------------------------------------------------------------------===//
-#include "sanitizer_common/sanitizer_common.h"
-#include "xray_fdr_logging.h"
-#include "gtest/gtest.h"
-
-#include <array>
-#include <fcntl.h>
-#include <iostream>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/types.h>
-#include <system_error>
-#include <thread>
-#include <unistd.h>
-
-#include "xray/xray_records.h"
-
-namespace __xray {
-namespace {
-
-constexpr auto kBufferSize = 16384;
-constexpr auto kBufferMax = 10;
-
-struct ScopedFileCloserAndDeleter {
-  explicit ScopedFileCloserAndDeleter(int Fd, const char *Filename)
-      : Fd(Fd), Filename(Filename) {}
-
-  ~ScopedFileCloserAndDeleter() {
-    if (Map)
-      munmap(Map, Size);
-    if (Fd) {
-      close(Fd);
-      unlink(Filename);
-    }
-  }
-
-  void registerMap(void *M, size_t S) {
-    Map = M;
-    Size = S;
-  }
-
-  int Fd;
-  const char *Filename;
-  void *Map = nullptr;
-  size_t Size = 0;
-};
-
-TEST(FDRLoggingTest, Simple) {
-  FDRLoggingOptions Options;
-  Options.ReportErrors = true;
-  char TmpFilename[] = "fdr-logging-test.XXXXXX";
-  Options.Fd = mkstemp(TmpFilename);
-  ASSERT_NE(Options.Fd, -1);
-  ASSERT_EQ(fdrLoggingInit(kBufferSize, kBufferMax, &Options,
-                           sizeof(FDRLoggingOptions)),
-            XRayLogInitStatus::XRAY_LOG_INITIALIZED);
-  fdrLoggingHandleArg0(1, XRayEntryType::ENTRY);
-  fdrLoggingHandleArg0(1, XRayEntryType::EXIT);
-  ASSERT_EQ(fdrLoggingFinalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
-  ASSERT_EQ(fdrLoggingFlush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-
-  // To do this properly, we have to close the file descriptor then re-open the
-  // file for reading this time.
-  ASSERT_EQ(close(Options.Fd), 0);
-  int Fd = open(TmpFilename, O_RDONLY);
-  ASSERT_NE(-1, Fd);
-  ScopedFileCloserAndDeleter Guard(Fd, TmpFilename);
-  auto Size = lseek(Fd, 0, SEEK_END);
-  ASSERT_NE(Size, 0);
-  // Map the file contents.
-  void *Map = mmap(NULL, Size, PROT_READ, MAP_PRIVATE, Fd, 0);
-  const char *Contents = static_cast<const char *>(Map);
-  Guard.registerMap(Map, Size);
-  ASSERT_NE(Contents, nullptr);
-
-  XRayFileHeader H;
-  memcpy(&H, Contents, sizeof(XRayFileHeader));
-  ASSERT_EQ(H.Version, 3);
-  ASSERT_EQ(H.Type, FileTypes::FDR_LOG);
-
-  // We require one buffer at least to have the "extents" metadata record,
-  // followed by the NewBuffer record.
-  MetadataRecord MDR0, MDR1;
-  memcpy(&MDR0, Contents + sizeof(XRayFileHeader), sizeof(MetadataRecord));
-  memcpy(&MDR1, Contents + sizeof(XRayFileHeader) + sizeof(MetadataRecord),
-         sizeof(MetadataRecord));
-  ASSERT_EQ(MDR0.RecordKind,
-            uint8_t(MetadataRecord::RecordKinds::BufferExtents));
-  ASSERT_EQ(MDR1.RecordKind, uint8_t(MetadataRecord::RecordKinds::NewBuffer));
-}
-
-TEST(FDRLoggingTest, Multiple) {
-  FDRLoggingOptions Options;
-  char TmpFilename[] = "fdr-logging-test.XXXXXX";
-  Options.Fd = mkstemp(TmpFilename);
-  ASSERT_NE(Options.Fd, -1);
-  ASSERT_EQ(fdrLoggingInit(kBufferSize, kBufferMax, &Options,
-                           sizeof(FDRLoggingOptions)),
-            XRayLogInitStatus::XRAY_LOG_INITIALIZED);
-  for (uint64_t I = 0; I < 100; ++I) {
-    fdrLoggingHandleArg0(1, XRayEntryType::ENTRY);
-    fdrLoggingHandleArg0(1, XRayEntryType::EXIT);
-  }
-  ASSERT_EQ(fdrLoggingFinalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
-  ASSERT_EQ(fdrLoggingFlush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-
-  // To do this properly, we have to close the file descriptor then re-open the
-  // file for reading this time.
-  ASSERT_EQ(close(Options.Fd), 0);
-  int Fd = open(TmpFilename, O_RDONLY);
-  ASSERT_NE(-1, Fd);
-  ScopedFileCloserAndDeleter Guard(Fd, TmpFilename);
-  auto Size = lseek(Fd, 0, SEEK_END);
-  ASSERT_NE(Size, 0);
-  // Map the file contents.
-  void *Map = mmap(NULL, Size, PROT_READ, MAP_PRIVATE, Fd, 0);
-  const char *Contents = static_cast<const char *>(Map);
-  Guard.registerMap(Map, Size);
-  ASSERT_NE(Contents, nullptr);
-
-  XRayFileHeader H;
-  memcpy(&H, Contents, sizeof(XRayFileHeader));
-  ASSERT_EQ(H.Version, 3);
-  ASSERT_EQ(H.Type, FileTypes::FDR_LOG);
-
-  MetadataRecord MDR0, MDR1;
-  memcpy(&MDR0, Contents + sizeof(XRayFileHeader), sizeof(MetadataRecord));
-  memcpy(&MDR1, Contents + sizeof(XRayFileHeader) + sizeof(MetadataRecord),
-         sizeof(MetadataRecord));
-  ASSERT_EQ(MDR0.RecordKind,
-            uint8_t(MetadataRecord::RecordKinds::BufferExtents));
-  ASSERT_EQ(MDR1.RecordKind, uint8_t(MetadataRecord::RecordKinds::NewBuffer));
-}
-
-TEST(FDRLoggingTest, MultiThreadedCycling) {
-  FDRLoggingOptions Options;
-  char TmpFilename[] = "fdr-logging-test.XXXXXX";
-  Options.Fd = mkstemp(TmpFilename);
-  ASSERT_NE(Options.Fd, -1);
-  ASSERT_EQ(fdrLoggingInit(kBufferSize, 1, &Options, sizeof(FDRLoggingOptions)),
-            XRayLogInitStatus::XRAY_LOG_INITIALIZED);
-
-  // Now we want to create one thread, do some logging, then create another one,
-  // in succession and making sure that we're able to get thread records from
-  // the latest thread (effectively being able to recycle buffers).
-  std::array<tid_t, 2> Threads;
-  for (uint64_t I = 0; I < 2; ++I) {
-    std::thread t{[I, &Threads] {
-      fdrLoggingHandleArg0(I + 1, XRayEntryType::ENTRY);
-      fdrLoggingHandleArg0(I + 1, XRayEntryType::EXIT);
-      Threads[I] = GetTid();
-    }};
-    t.join();
-  }
-  ASSERT_EQ(fdrLoggingFinalize(), XRayLogInitStatus::XRAY_LOG_FINALIZED);
-  ASSERT_EQ(fdrLoggingFlush(), XRayLogFlushStatus::XRAY_LOG_FLUSHED);
-
-  // To do this properly, we have to close the file descriptor then re-open the
-  // file for reading this time.
-  ASSERT_EQ(close(Options.Fd), 0);
-  int Fd = open(TmpFilename, O_RDONLY);
-  ASSERT_NE(-1, Fd);
-  ScopedFileCloserAndDeleter Guard(Fd, TmpFilename);
-  auto Size = lseek(Fd, 0, SEEK_END);
-  ASSERT_NE(Size, 0);
-  // Map the file contents.
-  void *Map = mmap(NULL, Size, PROT_READ, MAP_PRIVATE, Fd, 0);
-  const char *Contents = static_cast<const char *>(Map);
-  Guard.registerMap(Map, Size);
-  ASSERT_NE(Contents, nullptr);
-
-  XRayFileHeader H;
-  memcpy(&H, Contents, sizeof(XRayFileHeader));
-  ASSERT_EQ(H.Version, 3);
-  ASSERT_EQ(H.Type, FileTypes::FDR_LOG);
-
-  MetadataRecord MDR0, MDR1;
-  memcpy(&MDR0, Contents + sizeof(XRayFileHeader), sizeof(MetadataRecord));
-  memcpy(&MDR1, Contents + sizeof(XRayFileHeader) + sizeof(MetadataRecord),
-         sizeof(MetadataRecord));
-  ASSERT_EQ(MDR0.RecordKind,
-            uint8_t(MetadataRecord::RecordKinds::BufferExtents));
-  ASSERT_EQ(MDR1.RecordKind, uint8_t(MetadataRecord::RecordKinds::NewBuffer));
-  int32_t Latest = 0;
-  memcpy(&Latest, MDR1.Data, sizeof(int32_t));
-  ASSERT_EQ(Latest, static_cast<int32_t>(Threads[1]));
-}
-
-} // namespace
-} // namespace __xray

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

struct alignas(64) ThreadLocalData {
   size_t StackEntries = 0;
   int Fd = -1;
 };
 
 static pthread_key_t PThreadKey;
 
 static atomic_uint8_t BasicInitialized{0};
 
-BasicLoggingOptions GlobalOptions;
+struct BasicLoggingOptions {
+  int DurationFilterMicros = 0;
+  size_t MaxStackDepth = 0;
+  size_t ThreadBufferSize = 0;
+};
+
+struct BasicLoggingOptions GlobalOptions;
 
 thread_local atomic_uint8_t Guard{0};
 
 static atomic_uint8_t UseRealTSC{0};
 static atomic_uint64_t ThresholdTicks{0};
 static atomic_uint64_t TicksPerSec{0};
 static atomic_uint64_t CycleFrequency{NanosecondsPerSecond};
 
static void TLDDestructor(void *P) XRAY_NEVER_INSTRUMENT {
 
   // Because this thread's exit could be the last one trying to write to
   // the file and that we're not able to close out the file properly, we
   // sync instead and hope that the pending writes are flushed as the
   // thread exits.
   fsync(TLD.Fd);
 }
 
-XRayLogInitStatus basicLoggingInit(size_t BufferSize, size_t BufferMax,
-                                   void *Options,
+XRayLogInitStatus basicLoggingInit(UNUSED size_t BufferSize,
+                                   UNUSED size_t BufferMax, void *Options,
                                    size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
   uint8_t Expected = 0;
   if (!atomic_compare_exchange_strong(&BasicInitialized, &Expected, 1,
                                       memory_order_acq_rel)) {
     if (Verbosity())
       Report("Basic logging already initialized.\n");
     return XRayLogInitStatus::XRAY_LOG_INITIALIZED;
   }
 
   static pthread_once_t OnceInit = PTHREAD_ONCE_INIT;
   pthread_once(&OnceInit, +[] {
     pthread_key_create(&PThreadKey, TLDDestructor);
     atomic_store(&UseRealTSC, probeRequiredCPUFeatures(), memory_order_release);
     // Initialize the global TicksPerSec value.
     atomic_store(&TicksPerSec,
                  probeRequiredCPUFeatures() ? getTSCFrequency()
                                             : NanosecondsPerSecond,
                  memory_order_release);
     if (!atomic_load(&UseRealTSC, memory_order_relaxed) && Verbosity())
       Report("WARNING: Required CPU features missing for XRay instrumentation, "
              "using emulation instead.\n");
   });
 
-  if (BufferSize == 0 && BufferMax == 0 && Options != nullptr) {
-    FlagParser P;
-    BasicFlags F;
-    F.setDefaults();
-    registerXRayBasicFlags(&P, &F);
-    P.ParseString(useCompilerDefinedBasicFlags());
-    auto *EnvOpts = GetEnv("XRAY_BASIC_OPTIONS");
-    if (EnvOpts == nullptr)
-      EnvOpts = "";
 
-    P.ParseString(EnvOpts);
 
-    // If XRAY_BASIC_OPTIONS was not defined, then we use the deprecated options
-    // set through XRAY_OPTIONS instead.
-    if (internal_strlen(EnvOpts) == 0) {
-      F.func_duration_threshold_us =
-          flags()->xray_naive_log_func_duration_threshold_us;
-      F.max_stack_depth = flags()->xray_naive_log_max_stack_depth;
-      F.thread_buffer_size = flags()->xray_naive_log_thread_buffer_size;
-    }
 
-    P.ParseString(static_cast<const char *>(Options));
-    GlobalOptions.ThreadBufferSize = F.thread_buffer_size;
-    GlobalOptions.DurationFilterMicros = F.func_duration_threshold_us;
-    GlobalOptions.MaxStackDepth = F.max_stack_depth;
-    *basicFlags() = F;
-  } else if (OptionsSize != sizeof(BasicLoggingOptions)) {
-    Report("Invalid options size, potential ABI mismatch; expected %d got %d",
-           sizeof(BasicLoggingOptions), OptionsSize);
-    return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
-  } else {
-    if (Verbosity())
-      Report("XRay Basic: struct-based init is deprecated, please use "
-             "string-based configuration instead.\n");
-    GlobalOptions = *reinterpret_cast<BasicLoggingOptions *>(Options);
-  }
 
   atomic_store(&ThresholdTicks,
                atomic_load(&TicksPerSec, memory_order_acquire) *
                    GlobalOptions.DurationFilterMicros / 1000000,
                memory_order_release);
   __xray_set_handler_arg1(atomic_load(&UseRealTSC, memory_order_acquire)
                               ? basicLoggingHandleArg1RealTSC
                               : basicLoggingHandleArg1EmulateTSC);

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

 static pthread_key_t Key;
 
 // Global BufferQueue.
 static BufferQueue *BQ = nullptr;
 
 static atomic_sint32_t LogFlushStatus = {
     XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING};
 
-static FDRLoggingOptions FDROptions;
-
-static SpinMutex FDROptionsMutex;
-
 // This function will initialize the thread-local data structure used by the FDR
 // logging implementation and return a reference to it. The implementation
 // details require a bit of care to maintain.
 //
 // First, some requirements on the implementation in general:
 //
 //   - XRay handlers should not call any memory allocation routines that may
 //     delegate to an instrumented implementation. This means functions like
XRayLogFlushStatus fdrLoggingFlush() XRAY_NEVER_INSTRUMENT {
   //
   //   1) We write down the XRay file header with version 1, type FDR_LOG.
   //   2) Then we use the 'apply' member of the BufferQueue that's live, to
   //      ensure that at this point in time we write down the buffers that have
   //      been released (and marked "used") -- we dump the full buffer for now
   //      (fixed-sized) and let the tools reading the buffers deal with the data
   //      afterwards.
   //
-  int Fd = -1;
-  {
-    // FIXME: Remove this section of the code, when we remove the struct-based
-    // configuration API.
-    SpinMutexLock Guard(&FDROptionsMutex);
-    Fd = FDROptions.Fd;
-  }
-  if (Fd == -1)
-    Fd = getLogFD();
+  int Fd = getLogFD();
   if (Fd == -1) {
     auto Result = XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING;
     atomic_store(&LogFlushStatus, Result, memory_order_release);
     return Result;
   }
 
   XRayFileHeader Header = fdrCommonHeaderInfo();
   Header.FdrData = FdrAdditionalHeaderData{BQ->ConfiguredBufferSize()};
void fdrLoggingHandleTypedEvent(
 
   TLD.RecordPtr += sizeof(TypedEvent);
   internal_memcpy(TLD.RecordPtr, Event, ReducedEventSize);
   TLD.RecordPtr += ReducedEventSize;
   incrementExtents(MetadataRecSize + EventSize);
   endBufferIfFull();
 }
 
-XRayLogInitStatus fdrLoggingInit(size_t BufferSize, size_t BufferMax,
-                                 void *Options,
+XRayLogInitStatus fdrLoggingInit(UNUSED size_t BufferSize,
+                                 UNUSED size_t BufferMax, void *Options,
                                  size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
   if (Options == nullptr)
     return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
 
   s32 CurrentStatus = XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
   if (!atomic_compare_exchange_strong(&LoggingStatus, &CurrentStatus,
                                       XRayLogInitStatus::XRAY_LOG_INITIALIZING,
                                       memory_order_release)) {
     if (Verbosity())
       Report("Cannot initialize already initialized implementation.\n");
     return static_cast<XRayLogInitStatus>(CurrentStatus);
   }
 
-  // Because of __xray_log_init_mode(...) which guarantees that this will be
-  // called with BufferSize == 0 and BufferMax == 0 we parse the configuration
-  // provided in the Options pointer as a string instead.
-  if (BufferSize == 0 && BufferMax == 0) {
-    if (Verbosity())
-      Report("Initializing FDR mode with options: %s\n",
-             static_cast<const char *>(Options));
 
-    // TODO: Factor out the flags specific to the FDR mode implementation. For
-    // now, use the global/single definition of the flags, since the FDR mode
-    // flags are already defined there.
-    FlagParser FDRParser;
-    FDRFlags FDRFlags;
-    registerXRayFDRFlags(&FDRParser, &FDRFlags);
-    FDRFlags.setDefaults();
 
-    // Override first from the general XRAY_DEFAULT_OPTIONS compiler-provided
-    // options until we migrate everyone to use the XRAY_FDR_OPTIONS
-    // compiler-provided options.
-    FDRParser.ParseString(useCompilerDefinedFlags());
-    FDRParser.ParseString(useCompilerDefinedFDRFlags());
-    auto *EnvOpts = GetEnv("XRAY_FDR_OPTIONS");
-    if (EnvOpts == nullptr)
-      EnvOpts = "";
-    FDRParser.ParseString(EnvOpts);
 
-    // FIXME: Remove this when we fully remove the deprecated flags.
-    if (internal_strlen(EnvOpts) == 0) {
-      FDRFlags.func_duration_threshold_us =
-          flags()->xray_fdr_log_func_duration_threshold_us;
-      FDRFlags.grace_period_ms = flags()->xray_fdr_log_grace_period_ms;
-    }
 
-    // The provided options should always override the compiler-provided and
-    // environment-variable defined options.
-    FDRParser.ParseString(static_cast<const char *>(Options));
-    *fdrFlags() = FDRFlags;
-    BufferSize = FDRFlags.buffer_size;
-    BufferMax = FDRFlags.buffer_max;
-    SpinMutexLock Guard(&FDROptionsMutex);
-    FDROptions.Fd = -1;
-    FDROptions.ReportErrors = true;
-  } else if (OptionsSize != sizeof(FDRLoggingOptions)) {
-    // FIXME: This is deprecated, and should really be removed.
-    // At this point we use the flag parser specific to the FDR mode
-    // implementation.
-    if (Verbosity())
-      Report("Cannot initialize FDR logging; wrong size for options: %d\n",
-             OptionsSize);
-    return static_cast<XRayLogInitStatus>(
-        atomic_load(&LoggingStatus, memory_order_acquire));
-  } else {
-    if (Verbosity())
-      Report("XRay FDR: struct-based init is deprecated, please use "
-             "string-based configuration instead.\n");
-    SpinMutexLock Guard(&FDROptionsMutex);
-    internal_memcpy(&FDROptions, Options, OptionsSize);
-  }
 
   bool Success = false;
 
   if (BQ != nullptr) {
     BQ->~BufferQueue();
     InternalFree(BQ);
     BQ = nullptr;
   }

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

XRayLogInitStatus profilingFinalize() XRAY_NEVER_INSTRUMENT {
   profileCollectorService::serialize();
 
   atomic_store(&ProfilerLogStatus, XRayLogInitStatus::XRAY_LOG_FINALIZED,
                memory_order_release);
   return XRayLogInitStatus::XRAY_LOG_FINALIZED;
 }
 
 XRayLogInitStatus
-profilingLoggingInit(size_t BufferSize, size_t BufferMax, void *Options,
-                     size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
-  if (BufferSize != 0 || BufferMax != 0) {
-    if (Verbosity())
-      Report("__xray_log_init() being used, and is unsupported. Use "
-             "__xray_log_init_mode(...) instead. Bailing out.");
-    return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
-  }
-
+profilingLoggingInit(UNUSED size_t BufferSize, UNUSED size_t BufferMax,
+                     void *Options, size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
   s32 CurrentStatus = XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
   if (!atomic_compare_exchange_strong(&ProfilerLogStatus, &CurrentStatus,
                                       XRayLogInitStatus::XRAY_LOG_INITIALIZING,
                                       memory_order_release)) {
     if (Verbosity())
       Report("Cannot initialize already initialised profiling "
              "implementation.\n");
     return static_cast<XRayLogInitStatus>(CurrentStatus);

compiler-rt/trunk/test/xray/TestCases/Posix/fdr-mode.cc

 [[clang::xray_always_instrument]] void __attribute__((noinline)) fB() { fC(); }
 
 [[clang::xray_always_instrument]] void __attribute__((noinline)) fA() { fB(); }
 
 [[clang::xray_always_instrument, clang::xray_log_args(1)]]
 void __attribute__((noinline)) fArg(int) { }
 
 int main(int argc, char *argv[]) {
-  using namespace __xray;
   std::cout << "Logging before init." << std::endl;
   // CHECK: Logging before init.
   assert(__xray_log_select_mode("xray-fdr") ==
          XRayLogRegisterStatus::XRAY_REGISTRATION_OK);
   auto status =
       __xray_log_init_mode("xray-fdr", "buffer_size=16384:buffer_max=10");
   assert(status == XRayLogInitStatus::XRAY_LOG_INITIALIZED);
   std::cout << "Init status " << status << std::endl;

compiler-rt/trunk/test/xray/TestCases/Posix/fdr-single-thread.cc

 // RUN: %clangxx_xray -g -std=c++11 %s -o %t
 // RUN: rm -f fdr-logging-1thr-*
 // RUN: XRAY_OPTIONS=XRAY_OPTIONS="verbosity=1 patch_premain=true \
 // RUN:   xray_naive_log=false xray_fdr_log=true \
 // RUN:   xray_fdr_log_func_duration_threshold_us=0 \
 // RUN:   xray_logfile_base=fdr-logging-1thr-" %run %t 2>&1
 // RUN: %llvm_xray convert --output-format=yaml --symbolize --instr_map=%t \
 // RUN:   "`ls fdr-logging-1thr-* | head -n1`" | FileCheck %s
 // RUN: rm fdr-logging-1thr-*
 //
 // REQUIRES: x86_64-target-arch
 
 #include "xray/xray_log_interface.h"
 #include <cassert>
 
-constexpr auto kBufferSize = 16384;
-constexpr auto kBufferMax = 10;
-
 [[clang::xray_always_instrument]] void __attribute__((noinline)) fn() { }
 
 int main(int argc, char *argv[]) {
-  using namespace __xray;
   FDRLoggingOptions Opts;
 
-  auto status = __xray_log_init(kBufferSize, kBufferMax, &Opts, sizeof(Opts));
+  auto status = __xray_log_init_mode("xray-fdr", "");
   assert(status == XRayLogInitStatus::XRAY_LOG_INITIALIZED);
 
   __xray_patch();
   fn();
   __xray_unpatch();
   assert(__xray_log_finalize() == XRAY_LOG_FINALIZED);
   assert(__xray_log_flushLog() == XRAY_LOG_FLUSHED);
   return 0;
 }
 
 // CHECK: records:
 // CHECK-NEXT: - { type: 0, func-id: [[FID1:[0-9]+]], function: {{.*fn.*}}, cpu: {{.*}}, thread: [[THREAD1:[0-9]+]], process: [[PROCESS:[0-9]+]], kind: function-enter, tsc: {{[0-9]+}} }
 // CHECK-NEXT: - { type: 0, func-id: [[FID1:[0-9]+]], function: {{.*fn.*}}, cpu: {{.*}}, thread: [[THREAD1:[0-9]+]], process: [[PROCESS:[0-9]+]], kind: function-exit, tsc: {{[0-9]+}} }

compiler-rt/trunk/test/xray/TestCases/Posix/fdr-thread-order.cc

 // REQUIRES: x86_64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_log_interface.h"
 #include <atomic>
 #include <cassert>
 #include <thread>
 
-constexpr auto kBufferSize = 16384;
-constexpr auto kBufferMax = 10;
-
 std::atomic<uint64_t> var{0};
 
 [[clang::xray_always_instrument]] void __attribute__((noinline)) f1() {
   for (auto i = 0; i < 1 << 20; ++i)
     ++var;
 }
 
 [[clang::xray_always_instrument]] void __attribute__((noinline)) f2() {
   for (auto i = 0; i < 1 << 20; ++i)
     ++var;
 }
 
 int main(int argc, char *argv[]) {
-  using namespace __xray;
-  FDRLoggingOptions Options;
   __xray_patch();
-  assert(__xray_log_init(kBufferSize, kBufferMax, &Options,
-                         sizeof(FDRLoggingOptions)) ==
+  assert(__xray_log_init_mode("xray-fdr", "") ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED);
 
   std::atomic_thread_fence(std::memory_order_acq_rel);
 
   {
     std::thread t1([] { f1(); });
     std::thread t2([] { f2(); });
     t1.join();

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

 
 [[clang::xray_always_instrument]] int main(int, char **) {
   assert(__xray_log_select_mode("xray-profiling") ==
          XRayLogRegisterStatus::XRAY_REGISTRATION_OK);
   assert(__xray_log_get_current_mode() != nullptr);
   std::string current_mode = __xray_log_get_current_mode();
   assert(current_mode == "xray-profiling");
   assert(__xray_patch() == XRayPatchingStatus::SUCCESS);
-  assert(__xray_log_init(0, 0, nullptr, 0) ==
+  assert(__xray_log_init_mode("xray-profiling", "") ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED);
   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 threads, so we expect four buffers (including the file
   // header buffer).
   assert(buffer_counter == 4);
   assert(__xray_log_flushLog() == XRayLogFlushStatus::XRAY_LOG_FLUSHED);
 }