// 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 #include #include #include #include #include "base/containers/flat_map.h" #include "base/logging.h" #include "base/memory/ref_counted.h" #include "base/strings/stringprintf.h" #include "gpu/perftests/measurements.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" #include "testing/perf/perf_result_reporter.h" #include "ui/gfx/geometry/size.h" #include "ui/gfx/geometry/vector2d_f.h" #include "ui/gl/gl_bindings.h" #include "ui/gl/gl_context.h" #include "ui/gl/gl_enums.h" #include "ui/gl/gl_surface.h" #include "ui/gl/gl_utils.h" #include "ui/gl/gl_version_info.h" #include "ui/gl/gpu_timing.h" #include "ui/gl/init/gl_factory.h" #include "ui/gl/scoped_make_current.h" namespace gpu { namespace { const int kUploadPerfWarmupRuns = 5; const int kUploadPerfTestRuns = 30; #define SHADER(Src) #Src // clang-format off const char kVertexShader[] = SHADER( uniform vec2 translation; attribute vec2 a_position; attribute vec2 a_texCoord; varying vec2 v_texCoord; void main() { gl_Position = vec4( translation.x + a_position.x, translation.y + a_position.y, 0.0, 1.0); v_texCoord = a_texCoord; } ); const char kShaderDefaultFloatPrecision[] = SHADER( precision mediump float; ); const char kFragmentShader[] = SHADER( uniform sampler2D a_texture; varying vec2 v_texCoord; void main() { gl_FragColor = texture2D(a_texture, v_texCoord); } ); // clang-format on void CheckNoGlError(const std::string& msg) { const GLenum error = glGetError(); CHECK_EQ(static_cast(GL_NO_ERROR), error) << msg << " " << gl::GLEnums::GetStringError(error); } // Utility function to compile a shader from a string. GLuint LoadShader(const GLenum type, const char* const src) { GLuint shader = 0; shader = glCreateShader(type); CHECK_NE(0u, shader); glShaderSource(shader, 1, &src, nullptr); glCompileShader(shader); GLint compiled = 0; glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled); if (compiled == 0) { GLint len = 0; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len); if (len > 1) { std::unique_ptr error_log(new char[len]); glGetShaderInfoLog(shader, len, nullptr, error_log.get()); LOG(ERROR) << "Error compiling shader: " << error_log.get(); } } CHECK_NE(0, compiled); return shader; } int GLFormatBytePerPixel(GLenum format) { DCHECK(format == GL_RGBA || format == GL_LUMINANCE || format == GL_RED_EXT); return format == GL_RGBA ? 4 : 1; } GLenum GLFormatToInternalFormat(GLenum format) { return format == GL_RED ? GL_R8 : format; } GLenum GLFormatToStorageFormat(GLenum format) { switch (format) { case GL_RGBA: return GL_RGBA8; case GL_LUMINANCE: return GL_LUMINANCE8; case GL_RED: return GL_R8; default: NOTREACHED(); } return 0; } void GenerateTextureData(const gfx::Size& size, int bytes_per_pixel, const int seed, std::vector* const pixels) { // Row bytes has to be multiple of 4 (GL_PACK_ALIGNMENT defaults to 4). int stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3; pixels->resize(size.height() * stride); for (int y = 0; y < size.height(); ++y) { for (int x = 0; x < size.width(); ++x) { for (int channel = 0; channel < bytes_per_pixel; ++channel) { int index = y * stride + x * bytes_per_pixel; pixels->at(index) = (index + (seed << 2)) % (0x20 << channel); } } } } // Compare a buffer containing pixels in a specified format to GL_RGBA buffer // where the former buffer have been uploaded as a texture and drawn on the // RGBA buffer. bool CompareBufferToRGBABuffer(GLenum format, const gfx::Size& size, const std::vector& pixels, const std::vector& rgba) { int bytes_per_pixel = GLFormatBytePerPixel(format); int pixels_stride = ((size.width() * bytes_per_pixel) + 3) & ~0x3; int rgba_stride = size.width() * GLFormatBytePerPixel(GL_RGBA); for (int y = 0; y < size.height(); ++y) { for (int x = 0; x < size.width(); ++x) { int rgba_index = y * rgba_stride + x * GLFormatBytePerPixel(GL_RGBA); int pixels_index = y * pixels_stride + x * bytes_per_pixel; uint8_t expected[4] = {0}; switch (format) { case GL_LUMINANCE: // (L_t, L_t, L_t, 1) expected[1] = pixels[pixels_index]; expected[2] = pixels[pixels_index]; [[fallthrough]]; case GL_RED: // (R_t, 0, 0, 1) expected[0] = pixels[pixels_index]; expected[3] = 255; break; case GL_RGBA: // (R_t, G_t, B_t, A_t) memcpy(expected, &pixels[pixels_index], 4); break; default: NOTREACHED(); } if (memcmp(&rgba[rgba_index], expected, 4)) { return false; } } } return true; } // PerfTest to check costs of texture upload at different stages // on different platforms. class TextureUploadPerfTest : public testing::Test { public: TextureUploadPerfTest() : fbo_size_(1024, 1024) {} // Overridden from testing::Test void SetUp() override { // Initialize an offscreen surface and a gl context. surface_ = gl::init::CreateOffscreenGLSurface(gl::GetDefaultDisplay(), gfx::Size()); gl_context_ = gl::init::CreateGLContext(nullptr, // share_group surface_.get(), gl::GLContextAttribs()); ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get()); glGenTextures(1, &color_texture_); glBindTexture(GL_TEXTURE_2D, color_texture_); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fbo_size_.width(), fbo_size_.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glGenFramebuffersEXT(1, &framebuffer_object_); glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_object_); glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color_texture_, 0); DCHECK_EQ(static_cast(GL_FRAMEBUFFER_COMPLETE), glCheckFramebufferStatusEXT(GL_FRAMEBUFFER)); glViewport(0, 0, fbo_size_.width(), fbo_size_.height()); gpu_timing_client_ = gl_context_->CreateGPUTimingClient(); if (gpu_timing_client_->IsAvailable()) { LOG(INFO) << "Gpu timing initialized with timer type: " << gpu_timing_client_->GetTimerTypeName(); } 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. vertex_shader_ = LoadShader(GL_VERTEX_SHADER, kVertexShader); bool is_gles = gl_context_->GetVersionInfo()->is_es; fragment_shader_ = LoadShader( GL_FRAGMENT_SHADER, base::StringPrintf("%s%s", is_gles ? kShaderDefaultFloatPrecision : "", kFragmentShader).c_str()); program_object_ = glCreateProgram(); CHECK_NE(0u, program_object_); glAttachShader(program_object_, vertex_shader_); glAttachShader(program_object_, fragment_shader_); glBindAttribLocation(program_object_, 0, "a_position"); glBindAttribLocation(program_object_, 1, "a_texCoord"); glLinkProgram(program_object_); GLint linked = -1; glGetProgramiv(program_object_, GL_LINK_STATUS, &linked); CHECK_NE(0, linked); glUseProgram(program_object_); glUniform1i(sampler_location_, 0); translation_location_ = glGetUniformLocation(program_object_, "translation"); DCHECK_NE(-1, translation_location_); glUniform2f(translation_location_, 0.0f, 0.0f); sampler_location_ = glGetUniformLocation(program_object_, "a_texture"); CHECK_NE(-1, sampler_location_); glGenBuffersARB(1, &vertex_buffer_); CHECK_NE(0u, vertex_buffer_); DCHECK_NE(0u, vertex_buffer_); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, 0); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, reinterpret_cast(sizeof(GLfloat) * 2)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); CheckNoGlError("glEnableVertexAttribArray"); has_texture_storage_ = gl_context_->GetVersionInfo()->is_es3 || gl_context_->HasExtension("GL_EXT_texture_storage") || gl_context_->HasExtension("GL_ARB_texture_storage"); } void GenerateVertexBuffer(const gfx::Size& size) { DCHECK_NE(0u, vertex_buffer_); glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_); // right and top are in clipspace float right = -1.f + 2.f * size.width() / fbo_size_.width(); float top = -1.f + 2.f * size.height() / fbo_size_.height(); // Four vertexes, one per line. Each vertex has two components per // position and two per texcoord. // It represents a quad formed by two triangles if interpreted // as a tristrip. // clang-format off GLfloat data[16] = { -1.f, -1.f, 0.f, 0.f, right, -1.f, 1.f, 0.f, -1.f, top, 0.f, 1.f, right, top, 1.f, 1.f}; // clang-format on glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW); CheckNoGlError("glBufferData"); } void TearDown() override { ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get()); glDeleteProgram(program_object_); glDeleteShader(vertex_shader_); glDeleteShader(fragment_shader_); glDeleteBuffersARB(1, &vertex_buffer_); glBindFramebufferEXT(GL_FRAMEBUFFER, 0); glDeleteFramebuffersEXT(1, &framebuffer_object_); glDeleteTextures(1, &color_texture_); CheckNoGlError("glDeleteTextures"); gpu_timing_client_ = nullptr; gl_context_ = nullptr; surface_ = nullptr; } protected: GLuint CreateGLTexture(const GLenum format, const gfx::Size& size, const bool specify_storage) { GLuint texture_id = 0; glActiveTexture(GL_TEXTURE0); glGenTextures(1, &texture_id); glBindTexture(GL_TEXTURE_2D, texture_id); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(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); if (specify_storage) { if (has_texture_storage_) { glTexStorage2DEXT(GL_TEXTURE_2D, 1, GLFormatToStorageFormat(format), size.width(), size.height()); CheckNoGlError("glTexStorage2DEXT"); } else { glTexImage2D(GL_TEXTURE_2D, 0, GLFormatToInternalFormat(format), size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, nullptr); CheckNoGlError("glTexImage2D"); } } return texture_id; } void UploadTexture(GLuint texture_id, const gfx::Size& size, const std::vector& pixels, GLenum format, const bool subimage) { if (subimage) { glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size.width(), size.height(), format, GL_UNSIGNED_BYTE, &pixels[0]); CheckNoGlError("glTexSubImage2D"); } else { glTexImage2D(GL_TEXTURE_2D, 0, GLFormatToInternalFormat(format), size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, &pixels[0]); CheckNoGlError("glTexImage2D"); } } // 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 UploadAndDraw(GLuint texture_id, const gfx::Size& size, const std::vector& pixels, const GLenum format, const bool subimage) { MeasurementTimers tex_timers(gpu_timing_client_.get()); UploadTexture(texture_id, size, pixels, format, subimage); tex_timers.Record(); MeasurementTimers first_draw_timers(gpu_timing_client_.get()); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); first_draw_timers.Record(); MeasurementTimers draw_timers(gpu_timing_client_.get()); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); draw_timers.Record(); MeasurementTimers finish_timers(gpu_timing_client_.get()); glFinish(); CheckNoGlError("glFinish"); finish_timers.Record(); std::vector pixels_rendered(size.GetArea() * 4); glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_BYTE, &pixels_rendered[0]); CheckNoGlError("glReadPixels"); EXPECT_TRUE( CompareBufferToRGBABuffer(format, size, pixels, pixels_rendered)) << "Format is: " << gl::GLEnums::GetStringEnum(format); std::vector measurements; bool gpu_timer_errors = gpu_timing_client_->IsAvailable() && gpu_timing_client_->CheckAndResetTimerErrors(); if (!gpu_timer_errors) { measurements.push_back(tex_timers.GetAsMeasurement( subimage ? "texsubimage2d" : "teximage2d")); measurements.push_back( first_draw_timers.GetAsMeasurement("firstdrawarrays")); measurements.push_back(draw_timers.GetAsMeasurement("drawarrays")); measurements.push_back(finish_timers.GetAsMeasurement("finish")); } return measurements; } void RunUploadAndDrawMultipleTimes(const gfx::Size& size, const GLenum format, const bool subimage) { std::vector pixels; base::flat_map aggregates; // indexed by name int successful_runs = 0; GLuint texture_id = CreateGLTexture(format, size, subimage); for (int i = 0; i < kUploadPerfWarmupRuns + kUploadPerfTestRuns; ++i) { GenerateTextureData(size, GLFormatBytePerPixel(format), i + 1, &pixels); auto run = UploadAndDraw(texture_id, size, pixels, format, subimage); if (i < kUploadPerfWarmupRuns || run.empty()) { continue; } successful_runs++; for (const Measurement& measurement : run) { auto& aggregate = aggregates[measurement.metric_basename]; aggregate.metric_basename = measurement.metric_basename; aggregate.Increment(measurement); } } glDeleteTextures(1, &texture_id); std::string story_name = base::StringPrintf( "%d_%s", size.width(), gl::GLEnums::GetStringEnum(format).c_str()); if (subimage) { story_name += "_sub"; } if (successful_runs) { for (const auto& entry : aggregates) { const auto m = entry.second.Divide(successful_runs); m.PrintResult(story_name); } } auto reporter = std::make_unique( "sample_runs", story_name); reporter->RegisterImportantMetric("", "count"); reporter->AddResult("", static_cast(successful_runs)); } const gfx::Size fbo_size_; // for the fbo scoped_refptr gl_context_; scoped_refptr surface_; scoped_refptr gpu_timing_client_; GLuint color_texture_ = 0; GLuint framebuffer_object_ = 0; GLuint vertex_shader_ = 0; GLuint fragment_shader_ = 0; GLuint program_object_ = 0; GLint sampler_location_ = -1; GLint translation_location_ = -1; GLuint vertex_buffer_ = 0; bool has_texture_storage_ = false; }; // 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, upload) { int sizes[] = {21, 128, 256, 512, 1024}; std::vector formats; formats.push_back(GL_RGBA); if (!gl_context_->GetVersionInfo()->is_es3) { // Used by default for ResourceProvider::yuv_resource_format_. formats.push_back(GL_LUMINANCE); } ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get()); const bool has_texture_rg = gl_context_->GetVersionInfo()->is_es3 || gl_context_->HasExtension("GL_EXT_texture_rg") || gl_context_->HasExtension("GL_ARB_texture_rg"); if (has_texture_rg) { // Used as ResourceProvider::yuv_resource_format_ if // {ARB,EXT}_texture_rg are available. formats.push_back(GL_RED); } for (int side : sizes) { ASSERT_GE(fbo_size_.width(), side); ASSERT_GE(fbo_size_.height(), side); gfx::Size size(side, side); GenerateVertexBuffer(size); for (GLenum format : formats) { RunUploadAndDrawMultipleTimes(size, format, true); // use glTexSubImage2D RunUploadAndDrawMultipleTimes(size, format, false); // use glTexImage2D } } } // Perf test to check if the driver is doing texture renaming. // This test creates one GL texture_id and four different images. For // every image it uploads it using texture_id and it draws multiple // times. The cpu/wall time and the gpu time for all the uploads and // draws, but before glFinish, is computed and is printed out at the end as // "upload_and_draw". If the gpu time is >> than the cpu/wall time we expect the // driver to do texture renaming: this means that while the gpu is drawing using // texture_id it didn't block cpu side the texture upload using the same // texture_id. TEST_F(TextureUploadPerfTest, renaming) { gfx::Size texture_size(fbo_size_.width() / 2, fbo_size_.height() / 2); std::vector pixels[4]; for (int i = 0; i < 4; ++i) { GenerateTextureData(texture_size, 4, i + 1, &pixels[i]); } ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get()); 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()); for (int i = 0; i < 4; ++i) { UploadTexture(texture_id, texture_size, pixels[i % 4], GL_RGBA, 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) { 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 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"); } } } // namespace } // namespace gpu