TextureUploadPerfTest.renaming should output renaming status

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/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 486 matching lines @@
   GenerateVertexBuffer(texture_size);
 
   gfx::Vector2dF positions[] = {gfx::Vector2dF(0.f, 0.f),
                                 gfx::Vector2dF(1.f, 0.f),
                                 gfx::Vector2dF(0.f, 1.f),
                                 gfx::Vector2dF(1.f, 1.f)};
   GLuint texture_id = CreateGLTexture(GL_RGBA, texture_size, true);
 
   MeasurementTimers upload_and_draw_timers(gpu_timing_client_.get());
 
+  GLint current_tex_id = -1;
+  bool is_renaming = false;
   for (int i = 0; i < 4; ++i) {
     UploadTexture(texture_id, texture_size, pixels[i % 4], GL_RGBA, true);
+    if (!is_renaming && current_tex_id != -1 &&
+        static_cast<GLuint>(current_tex_id) != texture_id)
+      is_renaming = true;
     DCHECK_NE(-1, translation_location_);
     glUniform2f(translation_location_, positions[i % 4].x(),
                 positions[i % 4].y());
     // Draw the same quad multiple times to make sure that the time spent on the
     // gpu is more than the cpu time.
     for (int draw = 0; draw < 128; ++draw) {
+      glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_tex_id);

[Daniele Castagna, 2015/04/07 16:27:08]

This returns the name of the texture currently bound, that is the name of the
texture we just bound with glBindTexture(GL_TEXTURE_2D, texture_id).
This should always return texture_id.

AFAIU renaming is something the driver does under the hood and you should not be
able to see different texture names that were never generated. If this is
happening anywhere, this is a bug, let's investigate it.

[patro, 2015/04/08 15:19:49]

You are right this patch doesn't work as intended.
Then the only way to check if the gpu renames the texture is 
gpu_time > cpu_time

For this test we are printing only the cpu_time/gpu_time/wall_time
It will be more informative if we can also print if the gpu is renaming
textures.

On 2015/04/07 16:27:08, Daniele Castagna wrote:

[Daniele Castagna, 2015/04/14 16:13:15]

I was thinking about this perftest to print out raw data, then another script
could interpret the data and print out more human readable results.
In this way the final results could be determined given the raw data of all the
results (on different platforms/drivers) and not a single data point.

[sivag, 2015/04/27 12:39:02]

Daniele,
Can you elaborate more on this?
How this differs from comparing a two data arrays, 
1. the uploaded data pattern 2. the one read using glreadpixels
Which we are doing using EXPECT_EQ(pixels[i], pixels_rendered);?

       glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     }
   }
 
   upload_and_draw_timers.Record();
   MeasurementTimers finish_timers(gpu_timing_client_.get());
   glFinish();
   CheckNoGlError("glFinish");
   finish_timers.Record();
 
   glDeleteTextures(1, &texture_id);
 
   for (int i = 0; i < 4; ++i) {
     std::vector<uint8> pixels_rendered(texture_size.GetArea() * 4);
     glReadPixels(texture_size.width() * positions[i].x(),
                  texture_size.height() * positions[i].y(), texture_size.width(),
                  texture_size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError("glReadPixels");
     ASSERT_EQ(pixels[i].size(), pixels_rendered.size());
     EXPECT_EQ(pixels[i], pixels_rendered);
   }
 
   bool gpu_timer_errors = gpu_timing_client_->IsAvailable() &&
                           gpu_timing_client_->CheckAndResetTimerErrors();
   if (!gpu_timer_errors) {
     upload_and_draw_timers.GetAsMeasurement("upload_and_draw")
         .PrintResult("renaming");
     finish_timers.GetAsMeasurement("finish").PrintResult("renaming");
+    if (is_renaming)
+      perf_test::PrintResult("renaming", "",
+                             "Driver renames texture internally", "True", "",
+                             true);
+    else
+      perf_test::PrintResult("renaming", "",
+                             "Driver renames texture internally", "False", "",
+                             true);
   }
 }
 
 }  // namespace
 }  // namespace gpu