Tracing V2 prototype [NOT FOR REVIEW]

base/trace_event/trace_log.cc

 // Copyright 2015 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/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 23 matching lines @@
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "base/trace_event/trace_sampling_thread.h"
 #include "build/build_config.h"
 
+
 #if defined(OS_WIN)
 #include "base/trace_event/trace_event_etw_export_win.h"
 #endif
 
 // The thread buckets for the sampling profiler.
 BASE_EXPORT TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
 
 namespace base {
 namespace internal {
 
@@ skipping 144 matching lines @@
       locked_ = true;
     }
   }
 
  private:
   Lock* lock_;
   bool locked_;
   DISALLOW_COPY_AND_ASSIGN(OptionalAutoLock);
 };
 
+bool TraceLog::use_v2 = false;
+
 class TraceLog::ThreadLocalEventBuffer
     : public MessageLoop::DestructionObserver,
       public MemoryDumpProvider {
  public:
+   v2::ZeroCopyTraceBufferWriter* v2;
+
   explicit ThreadLocalEventBuffer(TraceLog* trace_log);
   ~ThreadLocalEventBuffer() override;
 
   TraceEvent* AddTraceEvent(TraceEventHandle* handle);
 
   TraceEvent* GetEventByHandle(TraceEventHandle handle) {
     if (!chunk_ || handle.chunk_seq != chunk_->seq() ||
         handle.chunk_index != chunk_index_) {
       return nullptr;
     }
 
     return chunk_->GetEventAt(handle.event_index);
   }
 
   int generation() const { return generation_; }
 
+  v2::ZeroCopyTraceBufferWriter v2_wri;
+
  private:
   // MessageLoop::DestructionObserver
   void WillDestroyCurrentMessageLoop() override;
 
   // MemoryDumpProvider implementation.
   bool OnMemoryDump(const MemoryDumpArgs& args,
                     ProcessMemoryDump* pmd) override;
 
   void FlushWhileLocked();
 
   void CheckThisIsCurrentBuffer() const {
     DCHECK(trace_log_->thread_local_event_buffer_.Get() == this);
   }
 
   // Since TraceLog is a leaky singleton, trace_log_ will always be valid
   // as long as the thread exists.
   TraceLog* trace_log_;
   std::unique_ptr<TraceBufferChunk> chunk_;
   size_t chunk_index_;
   int generation_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadLocalEventBuffer);
 };
 
 TraceLog::ThreadLocalEventBuffer::ThreadLocalEventBuffer(TraceLog* trace_log)
-    : trace_log_(trace_log),
+    : v2_wri(&trace_log->v2_rb, 42),
+      trace_log_(trace_log),
       chunk_index_(0),
       generation_(trace_log->generation()) {
   // ThreadLocalEventBuffer is created only if the thread has a message loop, so
   // the following message_loop won't be NULL.
   MessageLoop* message_loop = MessageLoop::current();
   message_loop->AddDestructionObserver(this);
 
   // This is to report the local memory usage when memory-infra is enabled.
   MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "ThreadLocalEventBuffer", ThreadTaskRunnerHandle::Get());
@@ skipping 86 matching lines @@
       process_sort_index_(0),
       process_id_hash_(0),
       process_id_(0),
       watch_category_(0),
       trace_options_(kInternalRecordUntilFull),
       sampling_thread_handle_(0),
       trace_config_(TraceConfig()),
       event_callback_trace_config_(TraceConfig()),
       thread_shared_chunk_index_(0),
       generation_(0),
-      use_worker_thread_(false) {
+      use_worker_thread_(false),
+      v2_rb(&v2_buf[0], sizeof(v2_buf)) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
   // traced or not, so we allow races on the enabled flag to keep the trace
   // macros fast.
   // TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
   // ANNOTATE_BENIGN_RACE_SIZED(g_category_group_enabled,
   //                            sizeof(g_category_group_enabled),
   //                           "trace_event category enabled");
   for (int i = 0; i < MAX_CATEGORY_GROUPS; ++i) {
     ANNOTATE_BENIGN_RACE(&g_category_group_enabled[i],
@@ skipping 191 matching lines @@
 
 void TraceLog::GetKnownCategoryGroups(
     std::vector<std::string>* category_groups) {
   AutoLock lock(lock_);
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = g_num_builtin_categories; i < category_index; i++)
     category_groups->push_back(g_category_groups[i]);
 }
 
 void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode mode) {
+  memset(v2_buf, 0, sizeof(v2_buf));
   std::vector<EnabledStateObserver*> observer_list;
   {
     AutoLock lock(lock_);
 
     // Can't enable tracing when Flush() is in progress.
     DCHECK(!flush_task_runner_);
 
     InternalTraceOptions new_options =
         GetInternalOptionsFromTraceConfig(trace_config);
 
@@ skipping 662 matching lines @@
     TraceEventETWExport::AddEvent(phase, category_group_enabled, name, id,
                                   num_args, arg_names, arg_types, arg_values,
                                   convertable_values);
 #endif  // OS_WIN
 
   std::string console_message;
   if (*category_group_enabled & ENABLED_FOR_RECORDING) {
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
+    if (TraceLog::use_v2) {
+      v2::TraceEventHandle evt = thread_local_event_buffer->v2_wri.AddEvent();
+      evt->set_thread_id(thread_id);
+      evt->set_timestamp(offset_event_timestamp.ToInternalValue());
+      evt->set_thread_timestamp(thread_now.ToInternalValue());
+      evt->set_type((::tracing::Event_Type) phase);
+      evt->set_category_id(static_cast<uint32_t>((uintptr_t)category_group_enabled));
+      evt->set_name_id(static_cast<uint32_t>((uintptr_t)name));
+      evt->set_id(id);
+      if (num_args > 0) {
+        tracing::EventArgsSimple* v2_args = evt->add_args_simple();
+
+        v2_args->set_arg_1_name_idx((uintptr_t) arg_names[0]);
+        switch(arg_types[0]) {
+          case TRACE_VALUE_TYPE_POINTER: {
+              // Super hack to test future convertable items. Assume that if a
+              // pointer was passed it was a pointer to a TraceEventHandle.
+              v2::TraceEventHandle* h = reinterpret_cast<v2::TraceEventHandle*>((uintptr_t)arg_values[0]);
+              *h = std::move(evt);
+            }
+            break;
+          case TRACE_VALUE_TYPE_BOOL:
+            v2_args->set_arg_1_bool_value(arg_values[0]); break;
+          // I am too lazy for all the cases :P
+          default:
+            v2_args->set_arg_1_int_value(arg_values[0]); break;
+            break;
+        }
+
+        if (num_args > 1) {
+          v2_args->set_arg_2_name_idx((uintptr_t) arg_names[1]);
+          switch(arg_types[1]) {
+            case TRACE_VALUE_TYPE_BOOL:
+              v2_args->set_arg_2_bool_value(arg_values[1]); break;
+            // I am too lazy for all the cases :P
+            default:
+              v2_args->set_arg_2_int_value(arg_values[1]); break;
+              break;
+          }
+        }
+      } // if num_args > 0
+    } else {
+
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
       lock.EnsureAcquired();
       trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
     }
 
     if (trace_event) {
       trace_event->Initialize(thread_id,
                               offset_event_timestamp,
                               thread_now,
                               phase,
                               category_group_enabled,
                               name,
                               scope,
                               id,
                               bind_id,
                               num_args,
                               arg_names,
                               arg_types,
                               arg_values,
                               convertable_values,
                               flags);
-
+    }  // else v2
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif
     }
 
     if (trace_options() & kInternalEchoToConsole) {
       console_message = EventToConsoleMessage(
           phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
           timestamp, trace_event);
     }
@@ skipping 456 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal