gpu/command_buffer/service/gpu_tracer.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/gpu_tracer.h"
   6
   7 #include <deque>
   8
   9 #include "base/bind.h"
  10 #include "base/location.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/time/time.h"
  15 #include "base/trace_event/trace_event.h"
  16 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  17 #include "gpu/command_buffer/service/context_group.h"
  18 #include "ui/gl/gl_bindings.h"
  19 #include "ui/gl/gl_version_info.h"
  20 #include "ui/gl/gpu_timing.h"
  21
  22 namespace gpu {
  23 namespace gles2 {
  24
  25 static const unsigned int kProcessInterval = 16;
  26 static const char* kGpuTraceSourceNames[] = {
  27   "GroupMarker", // kTraceGroupMarker = 0,
  28   "TraceCHROMIUM", // kTraceCHROMIUM = 1,
  29   "TraceCmd", // kTraceDecoder = 2,
  30 };
  31 static_assert(NUM_TRACER_SOURCES == arraysize(kGpuTraceSourceNames),
  32               "Trace source names must match enumeration.");
  33
  34 static TraceOutputter* g_outputter_thread = NULL;
  35
  36 TraceMarker::TraceMarker(const std::string& category, const std::string& name)
  37     : category_(category),
  38       name_(name),
  39       trace_(NULL) {
  40 }
  41
  42 TraceMarker::~TraceMarker() {
  43 }
  44
  45 scoped_refptr<TraceOutputter> TraceOutputter::Create(const std::string& name) {
  46   if (!g_outputter_thread) {
  47     g_outputter_thread = new TraceOutputter(name);
  48   }
  49   return g_outputter_thread;
  50 }
  51
  52 TraceOutputter::TraceOutputter(const std::string& name)
  53     : named_thread_(name.c_str()) {
  54   named_thread_.Start();
  55   named_thread_.Stop();
  56 }
  57
  58 TraceOutputter::~TraceOutputter() { g_outputter_thread = NULL; }
  59
  60 void TraceOutputter::TraceDevice(GpuTracerSource source,
  61                                  const std::string& category,
  62                                  const std::string& name,
  63                                  int64 start_time,
  64                                  int64 end_time) {
  65   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
  66   TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2(
  67       TRACE_DISABLED_BY_DEFAULT("gpu.device"),
  68       name.c_str(),
  69       local_trace_device_id_,
  70       named_thread_.thread_id(),
  71       start_time,
  72       "gl_category",
  73       category.c_str(),
  74       "channel",
  75       kGpuTraceSourceNames[source]);
  76   TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2(
  77       TRACE_DISABLED_BY_DEFAULT("gpu.device"),
  78       name.c_str(),
  79       local_trace_device_id_,
  80       named_thread_.thread_id(),
  81       end_time,
  82       "gl_category",
  83       category.c_str(),
  84       "channel",
  85       kGpuTraceSourceNames[source]);
  86   ++local_trace_device_id_;
  87 }
  88
  89 void TraceOutputter::TraceServiceBegin(GpuTracerSource source,
  90                                        const std::string& category,
  91                                        const std::string& name) {
  92   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
  93   TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2(
  94       TRACE_DISABLED_BY_DEFAULT("gpu.service"),
  95       name.c_str(), local_trace_service_id_,
  96       "gl_category", category.c_str(),
  97       "channel", kGpuTraceSourceNames[source]);
  98
  99   trace_service_id_stack_[source].push(local_trace_service_id_);
 100   ++local_trace_service_id_;
 101 }
 102
 103 void TraceOutputter::TraceServiceEnd(GpuTracerSource source,
 104                                      const std::string& category,
 105                                      const std::string& name) {
 106   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 107   DCHECK(!trace_service_id_stack_[source].empty());
 108   const uint64 local_trace_id = trace_service_id_stack_[source].top();
 109   trace_service_id_stack_[source].pop();
 110
 111   TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2(
 112       TRACE_DISABLED_BY_DEFAULT("gpu.service"),
 113       name.c_str(), local_trace_id,
 114       "gl_category", category.c_str(),
 115       "channel", kGpuTraceSourceNames[source]);
 116 }
 117
 118 GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
 119                    gfx::GPUTimingClient* gpu_timing_client,
 120                    const GpuTracerSource source,
 121                    const std::string& category,
 122                    const std::string& name,
 123                    const bool tracing_service,
 124                    const bool tracing_device)
 125     : source_(source),
 126       category_(category),
 127       name_(name),
 128       outputter_(outputter),
 129       service_enabled_(tracing_service),
 130       device_enabled_(tracing_device) {
 131   if (tracing_device &&
 132       gpu_timing_client->IsAvailable() &&
 133       gpu_timing_client->IsTimerOffsetAvailable()) {
 134     gpu_timer_ = gpu_timing_client->CreateGPUTimer();
 135   }
 136 }
 137
 138 GPUTrace::~GPUTrace() {
 139 }
 140
 141 void GPUTrace::Destroy(bool have_context) {
 142   if (gpu_timer_.get()) {
 143     gpu_timer_->Destroy(have_context);
 144   }
 145 }
 146
 147 void GPUTrace::Start() {
 148   if (service_enabled_) {
 149     outputter_->TraceServiceBegin(source_, category_, name_);
 150   }
 151   if (gpu_timer_.get()) {
 152     gpu_timer_->Start();
 153   }
 154 }
 155
 156 void GPUTrace::End() {
 157   if (gpu_timer_.get()) {
 158     gpu_timer_->End();
 159   }
 160   if (service_enabled_) {
 161     outputter_->TraceServiceEnd(source_, category_, name_);
 162   }
 163 }
 164
 165 bool GPUTrace::IsAvailable() {
 166   return !gpu_timer_.get() || gpu_timer_->IsAvailable();
 167 }
 168
 169 void GPUTrace::Process() {
 170   if (gpu_timer_.get()) {
 171     DCHECK(IsAvailable());
 172
 173     int64 start = 0;
 174     int64 end = 0;
 175     gpu_timer_->GetStartEndTimestamps(&start, &end);
 176     outputter_->TraceDevice(source_, category_, name_, start, end);
 177   }
 178 }
 179
 180 GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder)
 181     : gpu_trace_srv_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
 182           TRACE_DISABLED_BY_DEFAULT("gpu.service"))),
 183       gpu_trace_dev_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
 184           TRACE_DISABLED_BY_DEFAULT("gpu.device"))),
 185       decoder_(decoder),
 186       gpu_executing_(false),
 187       process_posted_(false) {
 188   DCHECK(decoder_);
 189   gfx::GLContext* context = decoder_->GetGLContext();
 190   if (context) {
 191     gpu_timing_client_ = context->CreateGPUTimingClient();
 192   } else {
 193     gpu_timing_client_ = new gfx::GPUTimingClient();
 194   }
 195 }
 196
 197 GPUTracer::~GPUTracer() {
 198 }
 199
 200 void GPUTracer::Destroy(bool have_context) {
 201   for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
 202     for (size_t i = 0; i < markers_[n].size(); i++) {
 203       TraceMarker& marker = markers_[n][i];
 204       if (marker.trace_.get()) {
 205         marker.trace_->Destroy(have_context);
 206         marker.trace_ = 0;
 207       }
 208     }
 209   }
 210
 211   ClearFinishedTraces(have_context);
 212 }
 213
 214 bool GPUTracer::BeginDecoding() {
 215   if (gpu_executing_)
 216     return false;
 217
 218   if (!outputter_) {
 219     outputter_ = CreateOutputter(gpu_timing_client_->GetTimerTypeName());
 220   }
 221
 222   if (*gpu_trace_dev_category == '\0') {
 223     // If GPU device category is off, invalidate timing sync.
 224     gpu_timing_client_->InvalidateTimerOffset();
 225   }
 226
 227   gpu_executing_ = true;
 228   if (IsTracing()) {
 229     gpu_timing_client_->CheckAndResetTimerErrors();
 230     // Begin a Trace for all active markers
 231     for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
 232       for (size_t i = 0; i < markers_[n].size(); i++) {
 233         TraceMarker& trace_marker = markers_[n][i];
 234         trace_marker.trace_ =
 235             new GPUTrace(outputter_, gpu_timing_client_.get(),
 236                          static_cast<GpuTracerSource>(n),
 237                          trace_marker.category_, trace_marker.name_,
 238                          *gpu_trace_srv_category != 0,
 239                          *gpu_trace_dev_category != 0);
 240         trace_marker.trace_->Start();
 241       }
 242     }
 243   }
 244   return true;
 245 }
 246
 247 bool GPUTracer::EndDecoding() {
 248   if (!gpu_executing_)
 249     return false;
 250
 251   // End Trace for all active markers
 252   if (IsTracing()) {
 253     for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
 254       if (!markers_[n].empty()) {
 255         for (int i = static_cast<int>(markers_[n].size()) - 1; i >= 0; --i) {
 256           TraceMarker& marker = markers_[n][i];
 257           if (marker.trace_.get()) {
 258             marker.trace_->End();
 259
 260             finished_traces_.push_back(marker.trace_);
 261             marker.trace_ = 0;
 262           }
 263         }
 264       }
 265     }
 266     IssueProcessTask();
 267   }
 268
 269   gpu_executing_ = false;
 270   return true;
 271 }
 272
 273 bool GPUTracer::Begin(const std::string& category, const std::string& name,
 274                       GpuTracerSource source) {
 275   if (!gpu_executing_)
 276     return false;
 277
 278   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 279
 280   // Push new marker from given 'source'
 281   markers_[source].push_back(TraceMarker(category, name));
 282
 283   // Create trace
 284   if (IsTracing()) {
 285     scoped_refptr<GPUTrace> trace = new GPUTrace(
 286         outputter_, gpu_timing_client_.get(), source, category, name,
 287         *gpu_trace_srv_category != 0,
 288         *gpu_trace_dev_category != 0);
 289     trace->Start();
 290     markers_[source].back().trace_ = trace;
 291   }
 292
 293   return true;
 294 }
 295
 296 bool GPUTracer::End(GpuTracerSource source) {
 297   if (!gpu_executing_)
 298     return false;
 299
 300   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 301
 302   // Pop last marker with matching 'source'
 303   if (!markers_[source].empty()) {
 304     scoped_refptr<GPUTrace> trace = markers_[source].back().trace_;
 305     if (trace.get()) {
 306       if (IsTracing()) {
 307         trace->End();
 308       }
 309
 310       finished_traces_.push_back(trace);
 311       IssueProcessTask();
 312     }
 313
 314     markers_[source].pop_back();
 315     return true;
 316   }
 317   return false;
 318 }
 319
 320 bool GPUTracer::IsTracing() {
 321   return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
 322 }
 323
 324 const std::string& GPUTracer::CurrentCategory(GpuTracerSource source) const {
 325   if (source >= 0 &&
 326       source < NUM_TRACER_SOURCES &&
 327       !markers_[source].empty()) {
 328     return markers_[source].back().category_;
 329   }
 330   return base::EmptyString();
 331 }
 332
 333 const std::string& GPUTracer::CurrentName(GpuTracerSource source) const {
 334   if (source >= 0 &&
 335       source < NUM_TRACER_SOURCES &&
 336       !markers_[source].empty()) {
 337     return markers_[source].back().name_;
 338   }
 339   return base::EmptyString();
 340 }
 341
 342 scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
 343   return TraceOutputter::Create(name);
 344 }
 345
 346 void GPUTracer::PostTask() {
 347   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 348       FROM_HERE, base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
 349       base::TimeDelta::FromMilliseconds(kProcessInterval));
 350 }
 351
 352 void GPUTracer::Process() {
 353   process_posted_ = false;
 354   ProcessTraces();
 355   IssueProcessTask();
 356 }
 357
 358 void GPUTracer::ProcessTraces() {
 359   if (!gpu_timing_client_->IsAvailable()) {
 360     ClearFinishedTraces(false);
 361     return;
 362   }
 363
 364   TRACE_EVENT0("gpu", "GPUTracer::ProcessTraces");
 365
 366   // Make owning decoder's GL context current
 367   if (!decoder_->MakeCurrent()) {
 368     // Skip subsequent GL calls if MakeCurrent fails
 369     ClearFinishedTraces(false);
 370     return;
 371   }
 372
 373   // Check if timers are still valid (e.g: a disjoint operation
 374   // might have occurred.)
 375   if (gpu_timing_client_->CheckAndResetTimerErrors()) {
 376     ClearFinishedTraces(true);
 377   }
 378
 379   while (!finished_traces_.empty()) {
 380     scoped_refptr<GPUTrace>& trace = finished_traces_.front();
 381     if (trace->IsDeviceTraceEnabled()) {
 382       if (!finished_traces_.front()->IsAvailable())
 383         break;
 384       finished_traces_.front()->Process();
 385     }
 386     finished_traces_.front()->Destroy(true);
 387     finished_traces_.pop_front();
 388   }
 389
 390   // Clear pending traces if there were are any errors
 391   GLenum err = glGetError();
 392   if (err != GL_NO_ERROR)
 393     ClearFinishedTraces(true);
 394 }
 395
 396 void GPUTracer::ClearFinishedTraces(bool have_context) {
 397   while (!finished_traces_.empty()) {
 398     finished_traces_.front()->Destroy(have_context);
 399     finished_traces_.pop_front();
 400   }
 401 }
 402
 403 void GPUTracer::IssueProcessTask() {
 404   if (finished_traces_.empty() || process_posted_)
 405     return;
 406
 407   process_posted_ = true;
 408   PostTask();
 409 }
 410
 411 }  // namespace gles2
 412 }  // namespace gpu