tracing v2: Add TraceRingBuffer class.

components/tracing/core/trace_ring_buffer.h

Index: components/tracing/core/trace_ring_buffer.h
diff --git a/components/tracing/core/trace_ring_buffer.h b/components/tracing/core/trace_ring_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..5721c8121929b017de86e9045270d480090a2eaf
--- /dev/null
+++ b/components/tracing/core/trace_ring_buffer.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_TRACING_CORE_TRACE_RING_BUFFER_H_
+#define COMPONENTS_TRACING_CORE_TRACE_RING_BUFFER_H_
+
+#include "base/atomicops.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/thread.h"
+#include "components/tracing/tracing_export.h"
+
+namespace tracing {
+namespace v2 {
+
+class TRACING_EXPORT TraceRingBuffer {
+ public:
+  class Chunk {
+   public:
+    using Header = base::subtle::Atomic32;
+    static constexpr size_t kSize = 32768;
+
+    Chunk();
+    ~Chunk();
+
+    void Initialize(uint8_t* begin);
+    void Clear();
+
+    uint8_t* begin() const { return begin_; }
+    Header* header() const { return reinterpret_cast<Header*>(begin_); }
+    uint8_t* payload() const { return begin_ + sizeof(Header); }
+    uint8_t* end() const { return begin_ + kSize; }
+
+    void set_used_size(uint32_t size) {
+      base::subtle::NoBarrier_Store(header(), size);
+    }
+    uint32_t used_size() const {
+      return base::subtle::NoBarrier_Load(header());
+    }
+
+    bool is_owned() const { return owner_ != base::kInvalidThreadId; }

[kraynov, 2016/06/28 13:15:16]

Is there a guarantee that is_owned(), clear_owner() and set_owner() are going to
be called in the same thread?

[Primiano Tucci (use gerrit), 2016/06/28 14:52:11]

No, see below, the expectations is that they are going to be accessed under the
lock_. Unfortunatelly I don't have a reference here to the parent obj so cannot
DCHECK that the lock is held.
But on the other side, these are impl details used only by the parent class.

+    void clear_owner() { owner_ = base::kInvalidThreadId; }
+    void set_owner(base::PlatformThreadId tid) { owner_ = tid; }
+
+   private:
+    uint8_t* begin_;
+
+    // Accesses to owner_ must happen under the buffer |lock_|.
+    base::PlatformThreadId owner_;  // kInvalidThreadId -> Chunk is returned.
+
+    DISALLOW_COPY_AND_ASSIGN(Chunk);
+  };
+
+  TraceRingBuffer(uint8_t* begin, size_t size);
+  ~TraceRingBuffer();
+
+  Chunk* TakeChunk();
+  void ReturnChunk(Chunk* chunk, uint32_t used_size);
+
+ private:
+  base::Lock lock_;
+  std::unique_ptr<Chunk[]> chunks_;
+  const size_t num_chunks_;
+  size_t current_chunk_idx_;
+
+  // An emergency chunk used in the rare case in which all chunks are in flight.
+  // This chunk is not part of the ring buffer and its contents are always
+  // discarded. Its only purpose is to avoid a crash (due to TakeChunk returning
+  // nullptr) in the case of a thread storm.
+  Chunk bankrupcy_chunk_;
+  std::unique_ptr<uint8_t[]> bankrupcy_chunk_storage_;
+
+  DISALLOW_COPY_AND_ASSIGN(TraceRingBuffer);
+};
+
+}  // namespace v2
+}  // namespace tracing
+
+#endif  // COMPONENTS_TRACING_CORE_TRACE_RING_BUFFER_H_