gpu: Add a class MeasurementTimers that measures wall, cpu and gpu time.

gpu/perftests/texture_upload_perftest.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 <algorithm>
 #include <vector>
 
 #include "base/containers/small_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/time/time.h"
-#include "base/timer/elapsed_timer.h"
+#include "gpu/perftests/measurements.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "testing/perf/perf_test.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace gpu {
 namespace {
 
 const int kUploadPerfWarmupRuns = 10;
@@ skipping 71 matching lines @@
 
   // Overridden from testing::Test
   void SetUp() override {
     // Initialize an offscreen surface and a gl context.
     gfx::GLSurface::InitializeOneOff();
     surface_ = gfx::GLSurface::CreateOffscreenGLSurface(size_);
     gl_context_ = gfx::GLContext::CreateGLContext(NULL,  // share_group
                                                   surface_.get(),
                                                   gfx::PreferIntegratedGpu);
 
+    ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
+    if (gpu_timing_.Initialize(gl_context_.get())) {
+      LOG(INFO) << "Gpu timing initialized with timer type: "
+                << gpu_timing_.GetTimerTypeName();
+      gpu_timing_.CheckAndResetTimerErrors();
+      gpu_timing_.InvalidateTimerOffset();
+    } else {
+      LOG(WARNING) << "Can't initialize gpu timing";
+    }
+
     // Prepare a simple program and a vertex buffer that will be
     // used to draw a quad on the offscreen surface.
-    ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
     vertex_shader_ = LoadShader(GL_VERTEX_SHADER, kVertexShader);
     fragment_shader_ = LoadShader(GL_FRAGMENT_SHADER, kFragmentShader);
     program_object_ = glCreateProgram();
     CHECK_NE(0u, program_object_);
 
     glAttachShader(program_object_, vertex_shader_);
     glAttachShader(program_object_, fragment_shader_);
     glBindAttribLocation(program_object_, 0, "a_position");
     glLinkProgram(program_object_);
 
@@ skipping 27 matching lines @@
     }
     if (vertex_buffer_ != 0) {
       glDeleteShader(vertex_buffer_);
     }
 
     gl_context_ = nullptr;
     surface_ = nullptr;
   }
 
  protected:
-  struct Measurement {
-    Measurement() : name(), wall_time(){};
-    Measurement(const std::string& name, const base::TimeDelta wall_time)
-        : name(name), wall_time(wall_time){};
-    std::string name;
-    base::TimeDelta wall_time;
-  };
   // Upload and draw on the offscren surface.
   // Return a list of pair. Each pair describe a gl operation and the wall
   // time elapsed in milliseconds.
   std::vector<Measurement> UploadAndDraw(const std::vector<uint8>& pixels,
                                          const GLenum format,
                                          const GLenum type) {
-    std::vector<Measurement> measurements;
     ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
 
-    base::ElapsedTimer total_timer;
+    MeasurementTimers total_timers(&gpu_timing_);
     GLuint texture_id = 0;
 
-    base::ElapsedTimer tex_timer;
+    MeasurementTimers tex_timers(&gpu_timing_);
     glActiveTexture(GL_TEXTURE0);
     glGenTextures(1, &texture_id);
     glBindTexture(GL_TEXTURE_2D, texture_id);
 
     glTexImage2D(GL_TEXTURE_2D, 0, format, size_.width(), size_.height(), 0,
                  format, type, &pixels[0]);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     CheckNoGlError();
-    measurements.push_back(Measurement("teximage2d", tex_timer.Elapsed()));
+    tex_timers.Record();
 
-    base::ElapsedTimer draw_timer;
+    MeasurementTimers draw_timers(&gpu_timing_);
     glUseProgram(program_object_);
     glUniform1i(sampler_location_, 0);
 
     glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
     glEnableVertexAttribArray(0);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-    measurements.push_back(Measurement("drawarrays", draw_timer.Elapsed()));
+    draw_timers.Record();
 
-    base::ElapsedTimer finish_timer;
+    MeasurementTimers finish_timers(&gpu_timing_);
     glFinish();
     CheckNoGlError();
-    measurements.push_back(Measurement("finish", finish_timer.Elapsed()));
-    measurements.push_back(Measurement("total", total_timer.Elapsed()));
+    finish_timers.Record();
+    total_timers.Record();
 
     glDeleteTextures(1, &texture_id);
 
     std::vector<uint8> pixels_rendered(size_.GetArea() * 4);
     glReadPixels(0, 0, size_.width(), size_.height(), GL_RGBA, type,
                  &pixels_rendered[0]);
     CheckNoGlError();
 
     // TODO(dcastagna): don't assume the format of the texture and do
     // the appropriate format conversion.
     EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
     EXPECT_EQ(pixels, pixels_rendered);
+
+    std::vector<Measurement> measurements;
+    measurements.push_back(total_timers.GetAsMeasurement("total"));
+    measurements.push_back(tex_timers.GetAsMeasurement("teximage2d"));
+    measurements.push_back(draw_timers.GetAsMeasurement("drawarrays"));
+    measurements.push_back(finish_timers.GetAsMeasurement("finish"));
     return measurements;
   }
 
   const gfx::Size size_;  // for the offscreen surface and the texture
   scoped_refptr<gfx::GLContext> gl_context_;
   scoped_refptr<gfx::GLSurface> surface_;
+  GPUTiming gpu_timing_;
 
   GLuint vertex_shader_ = 0;
   GLuint fragment_shader_ = 0;
   GLuint program_object_ = 0;
   GLint sampler_location_ = -1;
   GLuint vertex_buffer_ = 0;
 };
 
 // Perf test that generates, uploads and draws a texture on a surface repeatedly
 // and prints out aggregated measurements for all the runs.
 TEST_F(TextureUploadPerfTest, glTexImage2d) {
   std::vector<uint8> pixels;
   base::SmallMap<std::map<std::string, Measurement>>
       aggregates;  // indexed by name
   for (int i = 0; i < kUploadPerfWarmupRuns + kUploadPerfTestRuns; ++i) {
     GenerateTextureData(size_, i + 1, &pixels);
     auto run = UploadAndDraw(pixels, GL_RGBA, GL_UNSIGNED_BYTE);
     if (i >= kUploadPerfWarmupRuns) {
       for (const Measurement& m : run) {
         auto& agg = aggregates[m.name];
         agg.name = m.name;
-        agg.wall_time += m.wall_time;
+        agg.Increment(m);
       }
     }
   }
 
   for (const auto& entry : aggregates) {
-    const auto& m = entry.second;
-    perf_test::PrintResult(
-        m.name, "", "", (m.wall_time / kUploadPerfTestRuns).InMillisecondsF(),
-        "ms", true);
+    const auto m = entry.second.Divide(kUploadPerfTestRuns);
+    m.PrintResult();
   }
 }
 
 }  // namespace
 }  // namespace gpu