Make trace buffer size configurable

Add a config param to limit the total trace buffer size

BUG=859260

Change-Id: Ic15e5aa0d381273eadcdad270d955441386cd288
Reviewed-on: https://chromium-review.googlesource.com/1182510
Commit-Queue: Siddhartha S <ssid@chromium.org>
Reviewed-by: oysteine <oysteine@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584654}

base/trace_event/trace_config.cc

@@ -31,6 +31,7 @@ const char kEnableArgumentFilter[] = "enable-argument-filter";
 
 // String parameters that can be used to parse the trace config string.
 const char kRecordModeParam[] = "record_mode";
+const char kTraceBufferSizeInEvents[] = "trace_buffer_size_in_events";
 const char kEnableSystraceParam[] = "enable_systrace";
 const char kEnableArgumentFilterParam[] = "enable_argument_filter";
 
@@ -287,6 +288,7 @@ TraceConfig& TraceConfig::operator=(const TraceConfig& rhs) {
     return *this;
 
   record_mode_ = rhs.record_mode_;
+  trace_buffer_size_in_events_ = rhs.trace_buffer_size_in_events_;
   enable_systrace_ = rhs.enable_systrace_;
   enable_argument_filter_ = rhs.enable_argument_filter_;
   category_filter_ = rhs.category_filter_;
@@ -326,6 +328,8 @@ void TraceConfig::Merge(const TraceConfig& config) {
     DLOG(ERROR) << "Attempting to merge trace config with a different "
                 << "set of options.";
   }
+  DCHECK_EQ(trace_buffer_size_in_events_, config.trace_buffer_size_in_events_)
+      << "Cannot change trace buffer size";
 
   category_filter_.Merge(config.category_filter_);
   memory_dump_config_.Merge(config.memory_dump_config_);
@@ -337,6 +341,7 @@ void TraceConfig::Merge(const TraceConfig& config) {
 
 void TraceConfig::Clear() {
   record_mode_ = RECORD_UNTIL_FULL;
+  trace_buffer_size_in_events_ = 0;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   category_filter_.Clear();
@@ -347,6 +352,7 @@ void TraceConfig::Clear() {
 
 void TraceConfig::InitializeDefault() {
   record_mode_ = RECORD_UNTIL_FULL;
+  trace_buffer_size_in_events_ = 0;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
 }
@@ -365,6 +371,9 @@ void TraceConfig::InitializeFromConfigDict(const DictionaryValue& dict) {
       record_mode_ = RECORD_AS_MUCH_AS_POSSIBLE;
     }
   }
+  int buffer_size = 0;
+  trace_buffer_size_in_events_ =
+      dict.GetInteger(kTraceBufferSizeInEvents, &buffer_size) ? buffer_size : 0;
 
   bool val;
   enable_systrace_ = dict.GetBoolean(kEnableSystraceParam, &val) ? val : false;
@@ -403,6 +412,7 @@ void TraceConfig::InitializeFromStrings(StringPiece category_filter_string,
     category_filter_.InitializeFromString(category_filter_string);
 
   record_mode_ = RECORD_UNTIL_FULL;
+  trace_buffer_size_in_events_ = 0;
   enable_systrace_ = false;
   enable_argument_filter_ = false;
   if (!trace_options_string.empty()) {
@@ -535,6 +545,8 @@ std::unique_ptr<DictionaryValue> TraceConfig::ToDict() const {
                   TraceConfig::TraceRecordModeToStr(record_mode_));
   dict->SetBoolean(kEnableSystraceParam, enable_systrace_);
   dict->SetBoolean(kEnableArgumentFilterParam, enable_argument_filter_);
+  if (trace_buffer_size_in_events_ > 0)
+    dict->SetInteger(kTraceBufferSizeInEvents, trace_buffer_size_in_events_);
 
   category_filter_.ToDict(dict.get());
   process_filter_config_.ToDict(dict.get());

base/trace_event/trace_config.h

@@ -226,10 +226,16 @@ class BASE_EXPORT TraceConfig {
   TraceConfig& operator=(const TraceConfig& rhs);
 
   TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
+  size_t GetTraceBufferSizeInEvents() const {
+    return trace_buffer_size_in_events_;
+  }
   bool IsSystraceEnabled() const { return enable_systrace_; }
   bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
 
   void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
+  void SetTraceBufferSizeInEvents(size_t size) {
+    trace_buffer_size_in_events_ = size;
+  }
   void EnableSystrace() { enable_systrace_ = true; }
   void EnableArgumentFilter() { enable_argument_filter_ = true; }
 
@@ -304,6 +310,7 @@ class BASE_EXPORT TraceConfig {
   std::string ToTraceOptionsString() const;
 
   TraceRecordMode record_mode_;
+  size_t trace_buffer_size_in_events_ = 0;  // 0 specifies default size
   bool enable_systrace_ : 1;
   bool enable_argument_filter_ : 1;
 

base/trace_event/trace_config_unittest.cc

@@ -60,7 +60,8 @@ const char kCustomTraceConfigString[] =
     "}"
     "]"
     "},"
-    "\"record_mode\":\"record-continuously\""
+    "\"record_mode\":\"record-continuously\","
+    "\"trace_buffer_size_in_events\":100"
     "}";
 
 void CheckDefaultTraceConfigBehavior(const TraceConfig& tc) {
@@ -348,6 +349,7 @@ TEST(TraceConfigTest, TraceConfigFromDict) {
   EXPECT_EQ(RECORD_CONTINUOUSLY, custom_tc.GetTraceRecordMode());
   EXPECT_TRUE(custom_tc.IsSystraceEnabled());
   EXPECT_TRUE(custom_tc.IsArgumentFilterEnabled());
+  EXPECT_EQ(100u, custom_tc.GetTraceBufferSizeInEvents());
   EXPECT_STREQ(
       "included,inc_pattern*,"
       "disabled-by-default-cc,disabled-by-default-memory-infra,"

base/trace_event/trace_event_unittest.cc

@@ -2699,6 +2699,16 @@ TEST_F(TraceEventTestFixture, TraceRecordAsMuchAsPossibleMode) {
   TraceLog::GetInstance()->SetDisabled();
 }
 
+TEST_F(TraceEventTestFixture, ConfigTraceBufferLimit) {
+  const size_t kLimit = 2048;
+  TraceConfig config(kRecordAllCategoryFilter, RECORD_UNTIL_FULL);
+  config.SetTraceBufferSizeInEvents(kLimit);
+  TraceLog::GetInstance()->SetEnabled(config, TraceLog::RECORDING_MODE);
+  TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
+  EXPECT_EQ(kLimit, buffer->Capacity());
+  TraceLog::GetInstance()->SetDisabled();
+}
+
 void BlockUntilStopped(WaitableEvent* task_start_event,
                        WaitableEvent* task_stop_event) {
   task_start_event->Signal();

base/trace_event/trace_log.cc

@@ -625,7 +625,11 @@ void TraceLog::SetEnabled(const TraceConfig& trace_config,
     if (!(modes_to_enable & RECORDING_MODE) || already_recording)
       return;
 
-    if (new_options != old_options) {
+    // Discard events if new trace options are different. Reducing trace buffer
+    // size is not supported while already recording, so only replace trace
+    // buffer if we were not already recording.
+    if (new_options != old_options ||
+        (trace_config_.GetTraceBufferSizeInEvents() && !already_recording)) {
       subtle::NoBarrier_Store(&trace_options_, new_options);
       UseNextTraceBuffer();
     }
@@ -1718,20 +1722,26 @@ void TraceLog::SetCurrentThreadBlocksMessageLoop() {
 TraceBuffer* TraceLog::CreateTraceBuffer() {
   HEAP_PROFILER_SCOPED_IGNORE;
   InternalTraceOptions options = trace_options();
+  const size_t config_buffer_chunks =
+      trace_config_.GetTraceBufferSizeInEvents() / kTraceBufferChunkSize;
   if (options & kInternalRecordContinuously) {
     return TraceBuffer::CreateTraceBufferRingBuffer(
-        kTraceEventRingBufferChunks);
+        config_buffer_chunks > 0 ? config_buffer_chunks
+                                 : kTraceEventRingBufferChunks);
   }
   if (options & kInternalEchoToConsole) {
     return TraceBuffer::CreateTraceBufferRingBuffer(
-        kEchoToConsoleTraceEventBufferChunks);
+        config_buffer_chunks > 0 ? config_buffer_chunks
+                                 : kEchoToConsoleTraceEventBufferChunks);
   }
   if (options & kInternalRecordAsMuchAsPossible) {
     return TraceBuffer::CreateTraceBufferVectorOfSize(
-        kTraceEventVectorBigBufferChunks);
+        config_buffer_chunks > 0 ? config_buffer_chunks
+                                 : kTraceEventVectorBigBufferChunks);
   }
   return TraceBuffer::CreateTraceBufferVectorOfSize(
-      kTraceEventVectorBufferChunks);
+      config_buffer_chunks > 0 ? config_buffer_chunks
+                               : kTraceEventVectorBufferChunks);
 }
 
 #if defined(OS_WIN)

base/trace_event/trace_log.h

@@ -369,6 +369,7 @@ class BASE_EXPORT TraceLog : public MemoryDumpProvider {
                            ConvertTraceConfigToInternalOptions);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceRecordAsMuchAsPossibleMode);
+  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, ConfigTraceBufferLimit);
 
   friend class base::NoDestructor<TraceLog>;
 

components/tracing/common/trace_startup_config.cc

@@ -67,6 +67,8 @@ TraceStartupConfig::GetDefaultBrowserStartupConfig() {
   // Filter only browser process events.
   base::trace_event::TraceConfig::ProcessFilterConfig process_config(
       {base::GetCurrentProcId()});
+  // First 10k events at start are sufficient to debug startup traces.
+  trace_config.SetTraceBufferSizeInEvents(10000);
   trace_config.SetProcessFilterConfig(process_config);
   // Enable argument filter since we could be background tracing.
   trace_config.EnableArgumentFilter();