[XRay][compiler-rt] Remove dependency on <system_error>

[dberris]

Summary

Depending on C++11 <system_error> introduces a link-time requirement to
C++11 symbols. Removing it allows us to depend on header-only C++11 and
up libraries.

Partially fixes http://llvm.org/PR32274 -- we know there's more invasive work
to be done, but we're doing it incrementally.

[dblaikie]

Looks plausible/good to me.

[pelikan]

Code like from the good ol' days! It looks actually better than before ;-)

[kpw]

I'm a bit late to the party, but LGTM. I agree with Martin that this is preferable to the old revision in terms of clarity. "return BufferQueue::ErrorCode::Ok" beats "return {}" for reading in my book.

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

84–86 ↗

(On Diff #92596)

No action required here. Just a general style question.

enum class is sometimes annoying by removing the implicit cast to numeric.
For something like error codes, having the implicit cast is so natural.

What do you think of constructs where you still get scoping and implicit cast like:

class Errorcodes { enum Error { OK = 0, ... }; };

or similar with a namespace instead of a class?

[dberris]

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

84–86 ↗

(On Diff #92596)

I like that suggestion. I think it's probably something worth doing (inventing our own version of system error) later on, if it becomes something more useful not only in XRay. We can iterate on this and I'm definitely happy to make that easier to use going forward. But for now the only places where this is actually used is well contained and well defined enough that if it starts becoming a problem we can definitely go the way of a class that has a bit more semantics (explicit operator bool, error string accessor, etc).

lib/xray/tests/unit/buffer_queue_test.cc

 //===-- buffer_queue_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 "xray_buffer_queue.h"
 #include "gtest/gtest.h"
 
 #include <future>
-#include <system_error>
 #include <unistd.h>
 
 namespace __xray {
 
 static constexpr size_t kSize = 4096;
 
 TEST(BufferQueueTest, API) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
 }
 
 TEST(BufferQueueTest, GetAndRelease) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
-  ASSERT_EQ(Buffers.getBuffer(Buf), std::error_code());
+  ASSERT_EQ(Buffers.getBuffer(Buf), BufferQueue::ErrorCode::Ok);
   ASSERT_NE(nullptr, Buf.Buffer);
-  ASSERT_EQ(Buffers.releaseBuffer(Buf), std::error_code());
+  ASSERT_EQ(Buffers.releaseBuffer(Buf), BufferQueue::ErrorCode::Ok);
   ASSERT_EQ(nullptr, Buf.Buffer);
 }
 
 TEST(BufferQueueTest, GetUntilFailed) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf0;
-  EXPECT_EQ(Buffers.getBuffer(Buf0), std::error_code());
+  EXPECT_EQ(Buffers.getBuffer(Buf0), BufferQueue::ErrorCode::Ok);
   BufferQueue::Buffer Buf1;
-  EXPECT_EQ(std::make_error_code(std::errc::not_enough_memory),
-            Buffers.getBuffer(Buf1));
-  EXPECT_EQ(Buffers.releaseBuffer(Buf0), std::error_code());
+  EXPECT_EQ(BufferQueue::ErrorCode::NotEnoughMemory, Buffers.getBuffer(Buf1));
+  EXPECT_EQ(Buffers.releaseBuffer(Buf0), BufferQueue::ErrorCode::Ok);
 }
 
 TEST(BufferQueueTest, ReleaseUnknown) {
   bool Success = false;
   BufferQueue Buffers(kSize, 1, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
   Buf.Buffer = reinterpret_cast<void *>(0xdeadbeef);
   Buf.Size = kSize;
-  EXPECT_EQ(std::make_error_code(std::errc::argument_out_of_domain),
+  EXPECT_EQ(BufferQueue::ErrorCode::UnrecognizedBuffer,
             Buffers.releaseBuffer(Buf));
 }
 
 TEST(BufferQueueTest, ErrorsWhenFinalising) {
   bool Success = false;
   BufferQueue Buffers(kSize, 2, Success);
   ASSERT_TRUE(Success);
   BufferQueue::Buffer Buf;
-  ASSERT_EQ(Buffers.getBuffer(Buf), std::error_code());
+  ASSERT_EQ(Buffers.getBuffer(Buf), BufferQueue::ErrorCode::Ok);
   ASSERT_NE(nullptr, Buf.Buffer);
-  ASSERT_EQ(Buffers.finalize(), std::error_code());
+  ASSERT_EQ(Buffers.finalize(), BufferQueue::ErrorCode::Ok);
   BufferQueue::Buffer OtherBuf;
-  ASSERT_EQ(std::make_error_code(std::errc::state_not_recoverable),
+  ASSERT_EQ(BufferQueue::ErrorCode::AlreadyFinalized,
             Buffers.getBuffer(OtherBuf));
-  ASSERT_EQ(std::make_error_code(std::errc::state_not_recoverable),
+  ASSERT_EQ(BufferQueue::ErrorCode::AlreadyFinalized,
             Buffers.finalize());
-  ASSERT_EQ(Buffers.releaseBuffer(Buf), std::error_code());
+  ASSERT_EQ(Buffers.releaseBuffer(Buf), BufferQueue::ErrorCode::Ok);
 }
 
 TEST(BufferQueueTest, MultiThreaded) {
   bool Success = false;
   BufferQueue Buffers(kSize, 100, Success);
   ASSERT_TRUE(Success);
   auto F = [&] {
     BufferQueue::Buffer B;
-    while (!Buffers.getBuffer(B)) {
+    while (true) {
+      auto EC = Buffers.getBuffer(B);
+      if (EC != BufferQueue::ErrorCode::Ok)
+        return;
       Buffers.releaseBuffer(B);
     }
   };
   auto T0 = std::async(std::launch::async, F);
   auto T1 = std::async(std::launch::async, F);
   auto T2 = std::async(std::launch::async, [&] {
-    while (!Buffers.finalize())
+    while (Buffers.finalize() != BufferQueue::ErrorCode::Ok)
       ;
   });
   F();
 }
 
 TEST(BufferQueueTest, Apply) {
   bool Success = false;
   BufferQueue Buffers(kSize, 10, Success);
   ASSERT_TRUE(Success);
   auto Count = 0;
   BufferQueue::Buffer B;
   for (int I = 0; I < 10; ++I) {
-    ASSERT_FALSE(Buffers.getBuffer(B));
-    ASSERT_FALSE(Buffers.releaseBuffer(B));
+    ASSERT_EQ(Buffers.getBuffer(B), BufferQueue::ErrorCode::Ok);
+    ASSERT_EQ(Buffers.releaseBuffer(B), BufferQueue::ErrorCode::Ok);
   }
   Buffers.apply([&](const BufferQueue::Buffer &B) { ++Count; });
   ASSERT_EQ(Count, 10);
 }
 
 } // namespace __xray

lib/xray/xray_buffer_queue.h

 //===----------------------------------------------------------------------===//
 #ifndef XRAY_BUFFER_QUEUE_H
 #define XRAY_BUFFER_QUEUE_H
 
 #include <atomic>
 #include <cstdint>
 #include <deque>
 #include <mutex>
-#include <system_error>
 #include <unordered_set>
 #include <utility>
 
 namespace __xray {
 
 /// BufferQueue implements a circular queue of fixed sized buffers (much like a
 /// freelist) but is concerned mostly with making it really quick to initialise,
 /// finalise, and get/return buffers to the queue. This is one key component of
 /// the "flight data recorder" (FDR) mode to support ongoing XRay function call
 /// trace collection.
 class BufferQueue {
 public:
   struct Buffer {
     void *Buffer = nullptr;
-    std::size_t Size = 0;
+    size_t Size = 0;
   };
 
 private:
-  std::size_t BufferSize;
+  size_t BufferSize;
 
   // We use a bool to indicate whether the Buffer has been used in this
   // freelist implementation.
   std::deque<std::tuple<Buffer, bool>> Buffers;
   std::mutex Mutex;
   std::unordered_set<void *> OwnedBuffers;
   std::atomic<bool> Finalizing;
 
 public:
+  enum class ErrorCode : unsigned {
+    Ok,
+    NotEnoughMemory,
+    QueueFinalizing,
+    UnrecognizedBuffer,
+    AlreadyFinalized,
+  };
+
+  static const char *getErrorString(ErrorCode E) {
+    switch (E) {
+    case ErrorCode::Ok:
+      return "(none)";
+    case ErrorCode::NotEnoughMemory:
+      return "no available buffers in the queue";
+    case ErrorCode::QueueFinalizing:
+      return "queue already finalizing";
+    case ErrorCode::UnrecognizedBuffer:
+      return "buffer being returned not owned by buffer queue";
+    case ErrorCode::AlreadyFinalized:
+      return "queue already finalized";
+    }
+    return "unknown error";
+  }
+
   /// Initialise a queue of size |N| with buffers of size |B|. We report success
   /// through |Success|.
-  BufferQueue(std::size_t B, std::size_t N, bool &Success);
+  BufferQueue(size_t B, size_t N, bool &Success);
 
   /// Updates |Buf| to contain the pointer to an appropriate buffer. Returns an
   /// error in case there are no available buffers to return when we will run
   /// over the upper bound for the total buffers.
   ///
   /// Requirements:
   ///   - BufferQueue is not finalising.
   ///
   /// Returns:
   ///   - std::errc::not_enough_memory on exceeding MaxSize.
   ///   - no error when we find a Buffer.
   ///   - std::errc::state_not_recoverable on finalising BufferQueue.
-  std::error_code getBuffer(Buffer &Buf);
+  ErrorCode getBuffer(Buffer &Buf);
 
   /// Updates |Buf| to point to nullptr, with size 0.
   ///
   /// Returns:
   ///   - ...
-  std::error_code releaseBuffer(Buffer &Buf);
+  ErrorCode releaseBuffer(Buffer &Buf);
 
   bool finalizing() const { return Finalizing.load(std::memory_order_acquire); }
 
   /// Sets the state of the BufferQueue to finalizing, which ensures that:
   ///
   ///   - All subsequent attempts to retrieve a Buffer will fail.
   ///   - All releaseBuffer operations will not fail.
   ///
   /// After a call to finalize succeeds, all subsequent calls to finalize will
   /// fail with std::errc::state_not_recoverable.
-  std::error_code finalize();
+  ErrorCode finalize();
 
   /// Applies the provided function F to each Buffer in the queue, only if the
   /// Buffer is marked 'used' (i.e. has been the result of getBuffer(...) and a
   /// releaseBuffer(...) operation.
   template <class F> void apply(F Fn) {
     std::lock_guard<std::mutex> G(Mutex);
     for (const auto &T : Buffers) {
       if (std::get<1>(T))

lib/xray/xray_buffer_queue.cc

 //===-- xray_buffer_queue.cc -----------------------------------*- C++ -*-===//
 //
 //                     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 dynamic runtime instruementation system.
 //
 // Defines the interface for a buffer queue implementation.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_buffer_queue.h"
-#include <cassert>
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_libc.h"
+
 #include <cstdlib>
+#include <tuple>
 
 using namespace __xray;
+using namespace __sanitizer;
 
 BufferQueue::BufferQueue(std::size_t B, std::size_t N, bool &Success)
     : BufferSize(B), Buffers(N), Mutex(), OwnedBuffers(), Finalizing(false) {
   for (auto &T : Buffers) {
     void *Tmp = malloc(BufferSize);
     if (Tmp == nullptr) {
       Success = false;
       return;
     }
 
     auto &Buf = std::get<0>(T);
     Buf.Buffer = Tmp;
     Buf.Size = B;
     OwnedBuffers.emplace(Tmp);
   }
   Success = true;
 }
 
-std::error_code BufferQueue::getBuffer(Buffer &Buf) {
+BufferQueue::ErrorCode BufferQueue::getBuffer(Buffer &Buf) {
   if (Finalizing.load(std::memory_order_acquire))
-    return std::make_error_code(std::errc::state_not_recoverable);
+    return ErrorCode::QueueFinalizing;
   std::lock_guard<std::mutex> Guard(Mutex);
   if (Buffers.empty())
-    return std::make_error_code(std::errc::not_enough_memory);
+    return ErrorCode::NotEnoughMemory;
   auto &T = Buffers.front();
   auto &B = std::get<0>(T);
   Buf = B;
   B.Buffer = nullptr;
   B.Size = 0;
   Buffers.pop_front();
-  return {};
+  return ErrorCode::Ok;
 }
 
-std::error_code BufferQueue::releaseBuffer(Buffer &Buf) {
+BufferQueue::ErrorCode BufferQueue::releaseBuffer(Buffer &Buf) {
   if (OwnedBuffers.count(Buf.Buffer) == 0)
-    return std::make_error_code(std::errc::argument_out_of_domain);
+    return ErrorCode::UnrecognizedBuffer;
   std::lock_guard<std::mutex> Guard(Mutex);
 
   // Now that the buffer has been released, we mark it as "used".
   Buffers.emplace(Buffers.end(), Buf, true /* used */);
   Buf.Buffer = nullptr;
   Buf.Size = 0;
-  return {};
+  return ErrorCode::Ok;
 }
 
-std::error_code BufferQueue::finalize() {
+BufferQueue::ErrorCode BufferQueue::finalize() {
   if (Finalizing.exchange(true, std::memory_order_acq_rel))
-    return std::make_error_code(std::errc::state_not_recoverable);
-  return {};
+    return ErrorCode::QueueFinalizing;
+  return ErrorCode::Ok;
 }
 
 BufferQueue::~BufferQueue() {
   for (auto &T : Buffers) {
     auto &Buf = std::get<0>(T);
     free(Buf.Buffer);
   }
 }

lib/xray/xray_fdr_logging_impl.h

~ThreadExitBufferCleanup() noexcept XRAY_NEVER_INSTRUMENT {
 
     // We make sure that upon exit, a thread will write out the EOB
     // MetadataRecord in the thread-local log, and also release the buffer to
     // the queue.
     assert((RecordPtr + MetadataRecSize) - static_cast<char *>(Buffer.Buffer) >=
            static_cast<ptrdiff_t>(MetadataRecSize));
     if (auto BQ = Buffers.lock()) {
       writeEOBMetadata();
-      if (auto EC = BQ->releaseBuffer(Buffer))
+      auto EC = BQ->releaseBuffer(Buffer);
+      if (EC != BufferQueue::ErrorCode::Ok)
         Report("Failed to release buffer at %p; error=%s\n", Buffer.Buffer,
-               EC.message().c_str());
+               BufferQueue::getErrorString(EC));
       return;
     }
   }
 };
 
 class RecursionGuard {
   bool &Running;
   const bool Valid;

 };
 
 static inline bool loggingInitialized(
     const std::atomic<XRayLogInitStatus> &LoggingStatus) XRAY_NEVER_INSTRUMENT {
   return LoggingStatus.load(std::memory_order_acquire) ==
          XRayLogInitStatus::XRAY_LOG_INITIALIZED;
 }
 
-} // namespace anonymous
+} // namespace
 
 static inline void writeNewBufferPreamble(pid_t Tid, timespec TS,
                                           char *&MemPtr) XRAY_NEVER_INSTRUMENT {
   static constexpr int InitRecordsCount = 2;
   std::aligned_storage<sizeof(MetadataRecord)>::type Records[InitRecordsCount];
   {
     // Write out a MetadataRecord to signify that this is the start of a new
     // buffer, associated with a particular thread, with a new CPU.  For the
static inline void processFunctionHook(
   RecursionGuard Guard{Running};
   if (!Guard) {
     assert(Running == true && "RecursionGuard is buggy!");
     return;
   }
 
   if (!loggingInitialized(LoggingStatus) || LocalBQ->finalizing()) {
     writeEOBMetadata();
-    if (auto EC = BQ->releaseBuffer(Buffer)) {
+    auto EC = BQ->releaseBuffer(Buffer);
+    if (EC != BufferQueue::ErrorCode::Ok) {
       Report("Failed to release buffer at %p; error=%s\n", Buffer.Buffer,
-             EC.message().c_str());
+             BufferQueue::getErrorString(EC));
       return;
     }
     RecordPtr = nullptr;
   }
 
   if (Buffer.Buffer == nullptr) {
-    if (auto EC = LocalBQ->getBuffer(Buffer)) {
+    auto EC = LocalBQ->getBuffer(Buffer);
+    if (EC != BufferQueue::ErrorCode::Ok) {
       auto LS = LoggingStatus.load(std::memory_order_acquire);
       if (LS != XRayLogInitStatus::XRAY_LOG_FINALIZING &&
           LS != XRayLogInitStatus::XRAY_LOG_FINALIZED)
-        Report("Failed to acquire a buffer; error=%s\n", EC.message().c_str());
+        Report("Failed to acquire a buffer; error=%s\n",
+               BufferQueue::getErrorString(EC));
       return;
     }
 
     setupNewBuffer(Buffer, wall_clock_reader);
   }
 
   if (CurrentCPU == std::numeric_limits<uint16_t>::max()) {
     // This means this is the first CPU this thread has ever run on. We set the
static inline void processFunctionHook(
   // MetadataRecord. If we don't have enough space after writing as much as 24
   // bytes in the end of the buffer, we need to write out the EOB, get a new
   // Buffer, set it up properly before doing any further writing.
   //
   char *BufferStart = static_cast<char *>(Buffer.Buffer);
   if ((RecordPtr + (MetadataRecSize + FunctionRecSize)) - BufferStart <
       static_cast<ptrdiff_t>(MetadataRecSize)) {
     writeEOBMetadata();
-    if (auto EC = LocalBQ->releaseBuffer(Buffer)) {
+    auto EC = LocalBQ->releaseBuffer(Buffer);
+    if (EC != BufferQueue::ErrorCode::Ok) {
       Report("Failed to release buffer at %p; error=%s\n", Buffer.Buffer,
-             EC.message().c_str());
+             BufferQueue::getErrorString(EC));
       return;
     }
-    if (auto EC = LocalBQ->getBuffer(Buffer)) {
-      Report("Failed to acquire a buffer; error=%s\n", EC.message().c_str());
+    EC = LocalBQ->getBuffer(Buffer);
+    if (EC != BufferQueue::ErrorCode::Ok) {
+      Report("Failed to acquire a buffer; error=%s\n",
+             BufferQueue::getErrorString(EC));
       return;
     }
     setupNewBuffer(Buffer, wall_clock_reader);
   }
 
   // By this point, we are now ready to write at most 24 bytes (one metadata
   // record and one function record).
   BufferStart = static_cast<char *>(Buffer.Buffer);
static inline void processFunctionHook(
   CurrentCPU = CPU;
 
   writeFunctionRecord(FuncId, RecordTSCDelta, Entry, RecordPtr);
 
   // If we've exhausted the buffer by this time, we then release the buffer to
   // make sure that other threads may start using this buffer.
   if ((RecordPtr + MetadataRecSize) - BufferStart == MetadataRecSize) {
     writeEOBMetadata();
-    if (auto EC = LocalBQ->releaseBuffer(Buffer)) {
+    auto EC = LocalBQ->releaseBuffer(Buffer);
+    if (EC != BufferQueue::ErrorCode::Ok) {
       Report("Failed releasing buffer at %p; error=%s\n", Buffer.Buffer,
-             EC.message().c_str());
+             BufferQueue::getErrorString(EC));
       return;
     }
     RecordPtr = nullptr;
   }
 }
 
 } // namespace __xray_fdr_internal
 
 } // namespace __xray
 
 #endif // XRAY_XRAY_FDR_LOGGING_IMPL_H