Shrink trace_event buffers

base/debug/trace_event_impl.cc

 // Copyright (c) 2012 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.
 
 #include "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 };
 
 // The thread buckets for the sampling profiler.
 BASE_EXPORT TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
 
 namespace base {
 namespace debug {
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
-const size_t kTraceEventBufferSize = 500000;
+const size_t kTraceEventVectorBufferSize = 250000;
+const size_t kTraceEventRingBufferSize = kTraceEventVectorBufferSize / 4;
 const size_t kTraceEventBatchSize = 1000;
 const size_t kTraceEventInitialBufferSize = 1024;
 
 #define MAX_CATEGORY_GROUPS 100
 
 namespace {
 
 // Parallel arrays g_category_groups and g_category_group_enabled are separate
 // so that a pointer to a member of g_category_group_enabled can be easily
 // converted to an index into g_category_groups. This allows macros to deal
@@ skipping 17 matching lines @@
 // The name of the current thread. This is used to decide if the current
 // thread name has changed. We combine all the seen thread names into the
 // output name for the thread.
 LazyInstance<ThreadLocalPointer<const char> >::Leaky
     g_current_thread_name = LAZY_INSTANCE_INITIALIZER;
 
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kEnableSampling[] = "enable-sampling";
 
-size_t NextIndex(size_t index) {
-  index++;
-  if (index >= kTraceEventBufferSize)
-    index = 0;
-  return index;
-}
-
 }  // namespace
 
 class TraceBufferRingBuffer : public TraceBuffer {
  public:
   TraceBufferRingBuffer()
       : unused_event_index_(0),
         oldest_event_index_(0) {
     logged_events_.reserve(kTraceEventInitialBufferSize);
   }
 
@@ skipping 45 matching lines @@
 
   virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
     DCHECK(index < logged_events_.size());
     return logged_events_[index];
   }
 
   virtual size_t Size() const OVERRIDE {
     return logged_events_.size();
   }
 
+  virtual size_t Capacity() const OVERRIDE {
+    return kTraceEventRingBufferSize;
+  }
+
  private:
+  static size_t NextIndex(size_t index) {
+    index++;
+    if (index >= kTraceEventRingBufferSize)
+      index = 0;
+    return index;
+  }
+
   size_t unused_event_index_;
   size_t oldest_event_index_;
   std::vector<TraceEvent> logged_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
 };
 
 class TraceBufferVector : public TraceBuffer {
  public:
   TraceBufferVector() : current_iteration_index_(0) {
@@ skipping 15 matching lines @@
   virtual bool HasMoreEvents() const OVERRIDE {
     return current_iteration_index_ < Size();
   }
 
   virtual const TraceEvent& NextEvent() OVERRIDE {
     DCHECK(HasMoreEvents());
     return GetEventAt(current_iteration_index_++);
   }
 
   virtual bool IsFull() const OVERRIDE {
-    return Size() >= kTraceEventBufferSize;
+    return Size() >= kTraceEventVectorBufferSize;
   }
 
   virtual size_t CountEnabledByName(
       const unsigned char* category,
       const std::string& event_name) const OVERRIDE {
     size_t notify_count = 0;
     for (size_t i = 0; i < Size(); i++) {
       const TraceEvent& event = GetEventAt(i);
       if (category == event.category_group_enabled() &&
           strcmp(event_name.c_str(), event.name()) == 0) {
         ++notify_count;
       }
     }
     return notify_count;
   }
 
   virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
     DCHECK(index < logged_events_.size());
     return logged_events_[index];
   }
 
   virtual size_t Size() const OVERRIDE {
     return logged_events_.size();
   }
 
+  virtual size_t Capacity() const OVERRIDE {
+    return kTraceEventVectorBufferSize;
+  }
+
  private:
   size_t current_iteration_index_;
   std::vector<TraceEvent> logged_events_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceBufferVector);
 };
 
 class TraceBufferDiscardsEvents : public TraceBuffer {
  public:
   virtual ~TraceBufferDiscardsEvents() { }
 
   virtual void AddEvent(const TraceEvent& event) OVERRIDE {}
   virtual bool HasMoreEvents() const OVERRIDE { return false; }
 
   virtual const TraceEvent& NextEvent() OVERRIDE {
     NOTREACHED();
     return *static_cast<TraceEvent*>(NULL);
   }
 
   virtual bool IsFull() const OVERRIDE { return false; }
 
   virtual size_t CountEnabledByName(
       const unsigned char* category,
       const std::string& event_name) const OVERRIDE {
     return 0;
   }
 
   virtual size_t Size() const OVERRIDE { return 0; }
 
+  // As this buffer is never full, we can return any positive number.
+  virtual size_t Capacity() const OVERRIDE { return 1; }
+
   virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
     NOTREACHED();
     return *static_cast<TraceEvent*>(NULL);
   }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceEvent
 //
@@ skipping 817 matching lines @@
 
 bool TraceLog::HasEnabledStateObserver(EnabledStateObserver* listener) const {
   std::vector<EnabledStateObserver*>::const_iterator it =
       std::find(enabled_state_observer_list_.begin(),
                 enabled_state_observer_list_.end(),
                 listener);
   return it != enabled_state_observer_list_.end();
 }
 
 float TraceLog::GetBufferPercentFull() const {
-  return (float)((double)logged_events_->Size()/(double)kTraceEventBufferSize);
+  return static_cast<float>(static_cast<double>(logged_events_->Size()) /
+                            logged_events_->Capacity());
 }
 
 void TraceLog::SetNotificationCallback(
     const TraceLog::NotificationCallback& cb) {
   AutoLock lock(lock_);
   notification_callback_ = cb;
 }
 
 TraceBuffer* TraceLog::GetTraceBuffer() {
   if (trace_options_ & RECORD_CONTINUOUSLY)
@@ skipping 581 matching lines @@
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal