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..4aac3b78c5e0c5d5e90b9e30c0a7923e12b70ea9
--- /dev/null
+++ b/components/tracing/core/trace_ring_buffer.h
@@ -0,0 +1,81 @@
+// 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 const size_t kSize;
+
+    Chunk();
+    ~Chunk();
+
+    void Initialize(uint8_t* begin, uint8_t* end);

[oystein (OOO til 10th of July), 2016/06/15 07:52:52]

Maybe 'end' can just be omitted? Looks like end = begin + kSize is pretty
embedded in the usage (especially since kSize is a member of Chunk). Otherwise
maybe kSize should be moved to TraceRingBuffer::kChunkSize.

[Primiano Tucci (use gerrit), 2016/06/28 09:53:24]

Done.

+    void Clear();
+
+    uint8_t* begin() const { return begin_; }
+    Header* header() const { return reinterpret_cast<Header*>(begin_); }
+    uint8_t* proto_begin() const { return begin_ + sizeof(Header); }
+    uint8_t* end() const { return end_; }
+
+    void set_proto_used_size(uint32_t size) {
+      base::subtle::NoBarrier_Store(header(), size);
+    }
+    uint32_t proto_used_size() const {

[oystein (OOO til 10th of July), 2016/06/15 07:52:52]

Should this layer be proto aware? Maybe it could be juset set_used_size() /
used_size().

[Primiano Tucci (use gerrit), 2016/06/28 09:53:24]

Yup you are right, this is not proto aware. Renamed to set_used_size()

+      return base::subtle::NoBarrier_Load(header());
+    }
+
+    bool is_returned() const { return owner_ == base::kInvalidThreadId; }

[oystein (OOO til 10th of July), 2016/06/15 07:52:52]

is_returned() / and set_returned() was a little confusing to me. Maybe
is_owned() / clear_owner() instead?

[Primiano Tucci (use gerrit), 2016/06/28 09:53:24]

Done.

+    void set_returned() { owner_ = base::kInvalidThreadId; }
+    void set_owner(base::PlatformThreadId tid) { owner_ = tid; }
+
+   private:
+    uint8_t* begin_;
+    uint8_t* end_;
+
+    // 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_