| // Copyright (C) 2018 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| #include <gtest/gtest.h> |
| |
| #include "android/base/GLObjectCounter.h" |
| #include "android/base/files/PathUtils.h" |
| #include "android/base/perflogger/BenchmarkLibrary.h" |
| #include "android/base/system/System.h" |
| #include "android/base/threads/FunctorThread.h" |
| #include "android/opengles.h" |
| |
| #include "AndroidBufferQueue.h" |
| #include "AndroidWindow.h" |
| #include "AndroidWindowBuffer.h" |
| #include "ClientComposer.h" |
| #include "Display.h" |
| #include "GoldfishOpenglTestEnv.h" |
| #include "GrallocDispatch.h" |
| |
| #include <android/hardware_buffer.h> |
| #include <hardware/gralloc.h> |
| #include <EGL/egl.h> |
| #include <EGL/eglext.h> |
| #include <GLES3/gl3.h> |
| |
| #include <sstream> |
| #include <string> |
| |
| #include <stdio.h> |
| #include <sys/time.h> |
| |
| using aemu::AndroidBufferQueue; |
| using aemu::AndroidWindow; |
| using aemu::AndroidWindowBuffer; |
| using aemu::ClientComposer; |
| using aemu::Display; |
| |
| using android::base::FunctorThread; |
| using android::base::pj; |
| using android::base::System; |
| |
| static constexpr int kWindowSize = 256; |
| |
| class CombinedGoldfishOpenglTest : public ::testing::Test { |
| protected: |
| |
| static GoldfishOpenglTestEnv* testEnv; |
| |
| static void SetUpTestCase() { |
| testEnv = new GoldfishOpenglTestEnv; |
| } |
| |
| static void TearDownTestCase() { |
| delete testEnv; |
| testEnv = nullptr; |
| } |
| |
| struct EGLState { |
| EGLDisplay display = EGL_NO_DISPLAY; |
| EGLConfig config; |
| EGLSurface surface = EGL_NO_SURFACE; |
| EGLContext context = EGL_NO_CONTEXT; |
| }; |
| |
| void SetUp() override { |
| setupGralloc(); |
| setupEGLAndMakeCurrent(); |
| mBeforeTest = android::base::GLObjectCounter::get()->getCounts(); |
| } |
| |
| void TearDown() override { |
| if (eglGetCurrentContext() != EGL_NO_CONTEXT) { |
| glFinish(); // sync the pipe |
| } |
| mAfterTest = android::base::GLObjectCounter::get()->getCounts(); |
| for (int i = 0; i < mBeforeTest.size(); i++) { |
| EXPECT_TRUE(mBeforeTest[i] >= mAfterTest[i]) << |
| "Leaked objects of type " << i; |
| } |
| teardownEGL(); |
| teardownGralloc(); |
| } |
| |
| void setupGralloc() { |
| auto grallocPath = pj(System::get()->getProgramDirectory(), "lib64", |
| "gralloc.ranchu" LIBSUFFIX); |
| |
| load_gralloc_module(grallocPath.c_str(), &mGralloc); |
| set_global_gralloc_module(&mGralloc); |
| |
| EXPECT_NE(nullptr, mGralloc.fb_dev); |
| EXPECT_NE(nullptr, mGralloc.alloc_dev); |
| EXPECT_NE(nullptr, mGralloc.fb_module); |
| EXPECT_NE(nullptr, mGralloc.alloc_module); |
| } |
| |
| void teardownGralloc() { unload_gralloc_module(&mGralloc); } |
| |
| void setupEGLAndMakeCurrent() { |
| int maj, min; |
| |
| mEGL.display = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| EXPECT_EQ(EGL_TRUE, eglInitialize(mEGL.display, &maj, &min)); |
| |
| eglBindAPI(EGL_OPENGL_ES_API); |
| |
| static const EGLint configAttribs[] = { |
| EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, |
| EGL_OPENGL_ES2_BIT, EGL_NONE, |
| }; |
| |
| int numConfigs; |
| |
| EXPECT_EQ(EGL_TRUE, eglChooseConfig(mEGL.display, configAttribs, |
| &mEGL.config, 1, &numConfigs)) |
| << "Could not find GLES2 config!"; |
| |
| EXPECT_GT(numConfigs, 0); |
| |
| static const EGLint pbufAttribs[] = {EGL_WIDTH, kWindowSize, EGL_HEIGHT, |
| kWindowSize, EGL_NONE}; |
| |
| mEGL.surface = |
| eglCreatePbufferSurface(mEGL.display, mEGL.config, pbufAttribs); |
| |
| EXPECT_NE(EGL_NO_SURFACE, mEGL.surface) |
| << "Could not create pbuffer surface!"; |
| |
| static const EGLint contextAttribs[] = { |
| EGL_CONTEXT_CLIENT_VERSION, |
| 2, |
| EGL_NONE, |
| }; |
| |
| mEGL.context = eglCreateContext(mEGL.display, mEGL.config, |
| EGL_NO_CONTEXT, contextAttribs); |
| |
| EXPECT_NE(EGL_NO_CONTEXT, mEGL.context) << "Could not create context!"; |
| |
| EXPECT_EQ(EGL_TRUE, eglMakeCurrent(mEGL.display, mEGL.surface, |
| mEGL.surface, mEGL.context)) |
| << "eglMakeCurrent failed!"; |
| } |
| |
| void teardownEGL() { |
| eglRelease(); |
| |
| // Cancel all host threads as well |
| android_finishOpenglesRenderer(); |
| } |
| |
| void eglRelease() { |
| if (mEGL.display != EGL_NO_DISPLAY) { |
| EXPECT_EQ(EGL_TRUE, eglMakeCurrent(mEGL.display, EGL_NO_SURFACE, |
| EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
| EXPECT_EQ(EGL_TRUE, eglDestroyContext(mEGL.display, mEGL.context)); |
| EXPECT_EQ(EGL_TRUE, eglDestroySurface(mEGL.display, mEGL.surface)); |
| EXPECT_EQ(EGL_TRUE, eglTerminate(mEGL.display)); |
| EXPECT_EQ(EGL_TRUE, eglReleaseThread()); |
| } |
| |
| mEGL.display = EGL_NO_DISPLAY; |
| mEGL.context = EGL_NO_CONTEXT; |
| mEGL.surface = EGL_NO_SURFACE; |
| } |
| |
| buffer_handle_t createTestGrallocBuffer( |
| int usage = GRALLOC_USAGE_HW_RENDER, |
| int format = HAL_PIXEL_FORMAT_RGBA_8888, |
| int width = kWindowSize, |
| int height = kWindowSize) { |
| buffer_handle_t buffer; |
| int stride; |
| |
| mGralloc.alloc(width, height, format, usage, &buffer, &stride); |
| mGralloc.registerBuffer(buffer); |
| |
| (void)stride; |
| |
| return buffer; |
| } |
| |
| void destroyTestGrallocBuffer(buffer_handle_t buffer) { |
| mGralloc.unregisterBuffer(buffer); |
| mGralloc.free(buffer); |
| } |
| |
| std::vector<AndroidWindowBuffer> primeWindowBufferQueue(AndroidWindow& window) { |
| EXPECT_NE(nullptr, window.fromProducer); |
| EXPECT_NE(nullptr, window.toProducer); |
| |
| std::vector<AndroidWindowBuffer> buffers; |
| for (int i = 0; i < AndroidBufferQueue::kCapacity; i++) { |
| buffers.push_back(AndroidWindowBuffer( |
| &window, createTestGrallocBuffer())); |
| } |
| |
| for (int i = 0; i < AndroidBufferQueue::kCapacity; i++) { |
| window.fromProducer->queueBuffer(AndroidBufferQueue::Item( |
| (ANativeWindowBuffer*)(buffers.data() + i))); |
| } |
| return buffers; |
| } |
| |
| class WindowWithBacking { |
| public: |
| WindowWithBacking(CombinedGoldfishOpenglTest* _env) |
| : env(_env), window(kWindowSize, kWindowSize) { |
| window.setProducer(&toWindow, &fromWindow); |
| buffers = env->primeWindowBufferQueue(window); |
| } |
| |
| ~WindowWithBacking() { |
| for (auto& buffer : buffers) { |
| env->destroyTestGrallocBuffer(buffer.handle); |
| } |
| } |
| |
| CombinedGoldfishOpenglTest* env; |
| AndroidWindow window; |
| AndroidBufferQueue toWindow; |
| AndroidBufferQueue fromWindow; |
| std::vector<AndroidWindowBuffer> buffers; |
| }; |
| |
| struct gralloc_implementation mGralloc; |
| EGLState mEGL; |
| std::vector<size_t> mBeforeTest; |
| std::vector<size_t> mAfterTest; |
| }; |
| |
| // static |
| GoldfishOpenglTestEnv* CombinedGoldfishOpenglTest::testEnv = nullptr; |
| |
| // Tests that the pipe connection can be made and that |
| // gralloc/EGL can be set up. |
| |
| TEST_F(CombinedGoldfishOpenglTest, Basic) { } |
| |
| // Tests allocation and deletion of a gralloc buffer. |
| TEST_F(CombinedGoldfishOpenglTest, GrallocBuffer) { |
| buffer_handle_t buffer = createTestGrallocBuffer(); |
| destroyTestGrallocBuffer(buffer); |
| } |
| |
| // Tests basic GLES usage. |
| TEST_F(CombinedGoldfishOpenglTest, ViewportQuery) { |
| GLint viewport[4] = {}; |
| glGetIntegerv(GL_VIEWPORT, viewport); |
| |
| EXPECT_EQ(0, viewport[0]); |
| EXPECT_EQ(0, viewport[1]); |
| EXPECT_EQ(kWindowSize, viewport[2]); |
| EXPECT_EQ(kWindowSize, viewport[3]); |
| } |
| |
| // Tests eglCreateWindowSurface. |
| TEST_F(CombinedGoldfishOpenglTest, CreateWindowSurface) { |
| AndroidWindow testWindow(kWindowSize, kWindowSize); |
| |
| AndroidBufferQueue toWindow; |
| AndroidBufferQueue fromWindow; |
| |
| testWindow.setProducer(&toWindow, &fromWindow); |
| |
| AndroidWindowBuffer testBuffer(&testWindow, createTestGrallocBuffer()); |
| |
| toWindow.queueBuffer(AndroidBufferQueue::Item(&testBuffer)); |
| |
| static const EGLint attribs[] = {EGL_WIDTH, kWindowSize, EGL_HEIGHT, |
| kWindowSize, EGL_NONE}; |
| EGLSurface testEGLWindow = |
| eglCreateWindowSurface(mEGL.display, mEGL.config, |
| (EGLNativeWindowType)(&testWindow), attribs); |
| |
| EXPECT_NE(EGL_NO_SURFACE, testEGLWindow); |
| EXPECT_EQ(EGL_TRUE, eglDestroySurface(mEGL.display, testEGLWindow)); |
| |
| destroyTestGrallocBuffer(testBuffer.handle); |
| } |
| |
| // Starts a client composer, but doesn't do anything with it. |
| TEST_F(CombinedGoldfishOpenglTest, ClientCompositionSetup) { |
| |
| WindowWithBacking composeWindow(this); |
| WindowWithBacking appWindow(this); |
| |
| ClientComposer composer(&composeWindow.window, &appWindow.fromWindow, |
| &appWindow.toWindow); |
| } |
| |
| // Client composition, but also advances a frame. |
| TEST_F(CombinedGoldfishOpenglTest, ClientCompositionAdvanceFrame) { |
| WindowWithBacking composeWindow(this); |
| WindowWithBacking appWindow(this); |
| |
| AndroidBufferQueue::Item item; |
| |
| appWindow.toWindow.dequeueBuffer(&item); |
| appWindow.fromWindow.queueBuffer(item); |
| |
| ClientComposer composer(&composeWindow.window, &appWindow.fromWindow, |
| &appWindow.toWindow); |
| |
| composer.advanceFrame(); |
| composer.join(); |
| } |
| |
| TEST_F(CombinedGoldfishOpenglTest, ShowWindow) { |
| bool useWindow = |
| System::get()->envGet("ANDROID_EMU_TEST_WITH_WINDOW") == "1"; |
| aemu::Display disp(useWindow, kWindowSize, kWindowSize); |
| |
| if (useWindow) { |
| EXPECT_NE(nullptr, disp.getNative()); |
| android_showOpenglesWindow(disp.getNative(), 0, 0, kWindowSize, |
| kWindowSize, kWindowSize, kWindowSize, 1.0, |
| 0, false); |
| } |
| |
| for (int i = 0; i < 10; i++) { |
| disp.loop(); |
| System::get()->sleepMs(1); |
| } |
| |
| if (useWindow) android_hideOpenglesWindow(); |
| } |
| |
| TEST_F(CombinedGoldfishOpenglTest, DISABLED_ThreadCleanup) { |
| // initial clean up. |
| eglRelease(); |
| mBeforeTest = android::base::GLObjectCounter::get()->getCounts(); |
| for (int i = 0; i < 100; i++) { |
| std::unique_ptr<FunctorThread> th(new FunctorThread([this]() { |
| setupEGLAndMakeCurrent(); |
| eglRelease(); |
| })); |
| ; |
| th->start(); |
| th->wait(); |
| } |
| } |
| |
| // Test case adapted from https://buganizer.corp.google.com/issues/111228391 |
| TEST_F(CombinedGoldfishOpenglTest, SwitchContext) { |
| EXPECT_EQ(EGL_TRUE, eglMakeCurrent(mEGL.display, EGL_NO_SURFACE, |
| EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
| for (int i = 0; i < 100; i++) { |
| std::unique_ptr<FunctorThread> th(new FunctorThread([this]() { |
| EXPECT_EQ(EGL_TRUE, eglMakeCurrent(mEGL.display, mEGL.surface, |
| mEGL.surface, mEGL.context)); |
| EXPECT_EQ(EGL_TRUE, eglMakeCurrent(mEGL.display, EGL_NO_SURFACE, |
| EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
| })); |
| th->start(); |
| th->wait(); |
| } |
| } |
| |
| // Test that direct mapped memory works. |
| TEST_F(CombinedGoldfishOpenglTest, MappedMemory) { |
| constexpr GLsizei kBufferSize = 64; |
| |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glBufferData(GL_ARRAY_BUFFER, kBufferSize, 0, GL_DYNAMIC_DRAW); |
| |
| std::vector<uint8_t> data(kBufferSize); |
| for (uint8_t i = 0; i < kBufferSize; ++i) { |
| data[i] = i; |
| } |
| |
| uint8_t* mapped = |
| (uint8_t*) |
| glMapBufferRange( |
| GL_ARRAY_BUFFER, 0, kBufferSize, GL_MAP_WRITE_BIT); |
| |
| for (uint8_t i = 0; i < kBufferSize; ++i) { |
| mapped[i] = data[i]; |
| } |
| |
| glUnmapBuffer(GL_ARRAY_BUFFER); |
| |
| mapped = |
| (uint8_t*) |
| glMapBufferRange( |
| GL_ARRAY_BUFFER, 0, kBufferSize, GL_MAP_READ_BIT); |
| |
| for (uint8_t i = 0; i < kBufferSize; ++i) { |
| EXPECT_EQ(data[i], mapped[i]); |
| } |
| |
| glUnmapBuffer(GL_ARRAY_BUFFER); |
| |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| |
| // Test big buffer transfer |
| TEST_F(CombinedGoldfishOpenglTest, BigBuffer) { |
| constexpr GLsizei kBufferSize = 4096; |
| |
| std::vector<uint8_t> buf(kBufferSize); |
| |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glGetError(); |
| glBufferData(GL_ARRAY_BUFFER, kBufferSize, buf.data(), GL_DYNAMIC_DRAW); |
| |
| glGetError(); |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glDeleteBuffers(1, &buffer); |
| } |
| |
| static GLuint compileShader(GLenum shaderType, const char* src) { |
| GLuint shader = glCreateShader(shaderType); |
| glShaderSource(shader, 1, (const GLchar* const*)&src, nullptr); |
| glCompileShader(shader); |
| |
| GLint compileStatus; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus); |
| |
| if (compileStatus != GL_TRUE) { |
| GLsizei infoLogLength = 0; |
| glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength); |
| std::vector<char> infoLog(infoLogLength + 1, 0); |
| glGetShaderInfoLog(shader, infoLogLength, nullptr, infoLog.data()); |
| fprintf(stderr, "Failed to compile shader. Info log: [%s]\n", infoLog.data()); |
| } |
| |
| return shader; |
| } |
| |
| static GLint compileAndLinkShaderProgram(const char* vshaderSrc, |
| const char* fshaderSrc) { |
| GLuint vshader = compileShader(GL_VERTEX_SHADER, vshaderSrc); |
| GLuint fshader = compileShader(GL_FRAGMENT_SHADER, fshaderSrc); |
| |
| GLuint program = glCreateProgram(); |
| glAttachShader(program, vshader); |
| glAttachShader(program, fshader); |
| glLinkProgram(program); |
| |
| glDeleteShader(vshader); |
| glDeleteShader(fshader); |
| |
| GLint linkStatus; |
| glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); |
| |
| glClearColor(0.0f, 0.0f, 1.0f, 0.0f); |
| |
| if (linkStatus != GL_TRUE) { |
| GLsizei infoLogLength = 0; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength); |
| std::vector<char> infoLog(infoLogLength + 1, 0); |
| glGetProgramInfoLog(program, infoLogLength, nullptr, |
| infoLog.data()); |
| fprintf(stderr, "Failed to link program. Info log: [%s]\n", infoLog.data()); |
| } |
| |
| return program; |
| } |
| |
| // Test draw call rate. This is a perfgate benchmark |
| TEST_F(CombinedGoldfishOpenglTest, DrawCallRate) { |
| constexpr char vshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| layout (location = 0) in vec2 pos; |
| layout (location = 1) in vec3 color; |
| |
| uniform mat4 transform; |
| |
| out vec3 color_varying; |
| |
| void main() { |
| gl_Position = transform * vec4(pos, 0.0, 1.0); |
| color_varying = (transform * vec4(color, 1.0)).xyz; |
| } |
| )"; |
| constexpr char fshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| in vec3 color_varying; |
| |
| out vec4 fragColor; |
| |
| void main() { |
| fragColor = vec4(color_varying, 1.0); |
| } |
| )"; |
| |
| GLuint program = compileAndLinkShaderProgram(vshaderSrc, fshaderSrc); |
| |
| GLint transformLoc = glGetUniformLocation(program, "transform"); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| struct VertexAttributes { |
| float position[2]; |
| float color[3]; |
| }; |
| |
| const VertexAttributes vertexAttrs[] = { |
| { { -0.5f, -0.5f,}, { 0.2, 0.1, 0.9, }, }, |
| { { 0.5f, -0.5f,}, { 0.8, 0.3, 0.1,}, }, |
| { { 0.0f, 0.5f,}, { 0.1, 0.9, 0.6,}, }, |
| }; |
| |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertexAttrs), vertexAttrs, |
| GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), 0); |
| glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), |
| (GLvoid*)offsetof(VertexAttributes, color)); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| glUseProgram(program); |
| |
| glClearColor(0.2f, 0.2f, 0.3f, 0.0f); |
| glViewport(0, 0, 1, 1); |
| |
| float matrix[16] = { |
| 1.0f, 0.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 0.0f, 1.0f, |
| }; |
| |
| glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
| |
| uint32_t drawCount = 0; |
| static constexpr uint32_t kDrawCallLimit = 50000; |
| |
| auto cpuTimeStart = System::cpuTime(); |
| |
| while (drawCount < kDrawCallLimit) { |
| glUniformMatrix4fv(transformLoc, 1, GL_FALSE, matrix); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glDrawArrays(GL_TRIANGLES, 0, 3); |
| ++drawCount; |
| } |
| |
| // Need a round trip at the end to get an accurate measurement |
| glFinish(); |
| |
| auto cpuTime = System::cpuTime() - cpuTimeStart; |
| |
| uint64_t duration_us = cpuTime.wall_time_us; |
| uint64_t duration_cpu_us = cpuTime.usageUs(); |
| |
| float ms = duration_us / 1000.0f; |
| float sec = duration_us / 1000000.0f; |
| |
| float drawCallHz = kDrawCallLimit / sec; |
| |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glDeleteBuffers(1, &buffer); |
| glUseProgram(0); |
| glDeleteProgram(program); |
| |
| printf("Drew %u times in %f ms. Rate: %f Hz\n", kDrawCallLimit, ms, |
| drawCallHz); |
| |
| android::perflogger::logDrawCallOverheadTest( |
| (const char*)glGetString(GL_VENDOR), |
| (const char*)glGetString(GL_RENDERER), |
| (const char*)glGetString(GL_VERSION), |
| "drawArrays", "fullStack", |
| kDrawCallLimit, |
| (long)drawCallHz, |
| duration_us, |
| duration_cpu_us); |
| } |
| |
| extern "C" void glDrawArraysNullAEMU(GLenum mode, GLint first, GLsizei count); |
| |
| // Test draw call rate without drawing on the host driver, which gives numbers |
| // closer to pure emulator overhead. This is a perfgate benchmark |
| TEST_F(CombinedGoldfishOpenglTest, DrawCallRateOverheadOnly) { |
| constexpr char vshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| layout (location = 0) in vec2 pos; |
| layout (location = 1) in vec3 color; |
| |
| uniform mat4 transform; |
| |
| out vec3 color_varying; |
| |
| void main() { |
| gl_Position = transform * vec4(pos, 0.0, 1.0); |
| color_varying = (transform * vec4(color, 1.0)).xyz; |
| } |
| )"; |
| constexpr char fshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| in vec3 color_varying; |
| |
| out vec4 fragColor; |
| |
| void main() { |
| fragColor = vec4(color_varying, 1.0); |
| } |
| )"; |
| |
| GLuint program = compileAndLinkShaderProgram(vshaderSrc, fshaderSrc); |
| |
| GLint transformLoc = glGetUniformLocation(program, "transform"); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| struct VertexAttributes { |
| float position[2]; |
| float color[3]; |
| }; |
| |
| const VertexAttributes vertexAttrs[] = { |
| { { -0.5f, -0.5f,}, { 0.2, 0.1, 0.9, }, }, |
| { { 0.5f, -0.5f,}, { 0.8, 0.3, 0.1,}, }, |
| { { 0.0f, 0.5f,}, { 0.1, 0.9, 0.6,}, }, |
| }; |
| |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertexAttrs), vertexAttrs, |
| GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), 0); |
| glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), |
| (GLvoid*)offsetof(VertexAttributes, color)); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| glUseProgram(program); |
| |
| glClearColor(0.2f, 0.2f, 0.3f, 0.0f); |
| glViewport(0, 0, 1, 1); |
| |
| float matrix[16] = { |
| 1.0f, 0.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 0.0f, 1.0f, |
| }; |
| |
| glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
| |
| uint32_t drawCount = 0; |
| static constexpr uint32_t kDrawCallLimit = 2000000; |
| |
| auto cpuTimeStart = System::cpuTime(); |
| |
| while (drawCount < kDrawCallLimit) { |
| glUniformMatrix4fv(transformLoc, 1, GL_FALSE, matrix); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glDrawArraysNullAEMU(GL_TRIANGLES, 0, 3); |
| ++drawCount; |
| } |
| |
| // Need a round trip at the end to get an accurate measurement |
| glFinish(); |
| |
| auto cpuTime = System::cpuTime() - cpuTimeStart; |
| |
| uint64_t duration_us = cpuTime.wall_time_us; |
| uint64_t duration_cpu_us = cpuTime.usageUs(); |
| |
| float ms = duration_us / 1000.0f; |
| float sec = duration_us / 1000000.0f; |
| |
| float drawCallHz = kDrawCallLimit / sec; |
| |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glDeleteBuffers(1, &buffer); |
| glUseProgram(0); |
| glDeleteProgram(program); |
| |
| printf("Drew %u times in %f ms. Rate: %f Hz\n", kDrawCallLimit, ms, |
| drawCallHz); |
| |
| android::perflogger::logDrawCallOverheadTest( |
| (const char*)glGetString(GL_VENDOR), |
| (const char*)glGetString(GL_RENDERER), |
| (const char*)glGetString(GL_VERSION), |
| "drawArrays", "fullStackOverheadOnly", |
| kDrawCallLimit, |
| (long)drawCallHz, |
| duration_us, |
| duration_cpu_us); |
| } |
| |
| // Test uniform upload rate. This is a perfgate benchmark |
| TEST_F(CombinedGoldfishOpenglTest, UniformUploadRate) { |
| constexpr char vshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| layout (location = 0) in vec2 pos; |
| layout (location = 1) in vec3 color; |
| |
| uniform mat4 transform; |
| |
| out vec3 color_varying; |
| |
| void main() { |
| gl_Position = transform * vec4(pos, 0.0, 1.0); |
| color_varying = (transform * vec4(color, 1.0)).xyz; |
| } |
| )"; |
| constexpr char fshaderSrc[] = R"(#version 300 es |
| precision highp float; |
| |
| in vec3 color_varying; |
| |
| out vec4 fragColor; |
| |
| void main() { |
| fragColor = vec4(color_varying, 1.0); |
| } |
| )"; |
| |
| GLuint program = compileAndLinkShaderProgram(vshaderSrc, fshaderSrc); |
| |
| GLint transformLoc = glGetUniformLocation(program, "transform"); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| struct VertexAttributes { |
| float position[2]; |
| float color[3]; |
| }; |
| |
| const VertexAttributes vertexAttrs[] = { |
| { { -0.5f, -0.5f,}, { 0.2, 0.1, 0.9, }, }, |
| { { 0.5f, -0.5f,}, { 0.8, 0.3, 0.1,}, }, |
| { { 0.0f, 0.5f,}, { 0.1, 0.9, 0.6,}, }, |
| }; |
| |
| GLuint buffer; |
| glGenBuffers(1, &buffer); |
| glBindBuffer(GL_ARRAY_BUFFER, buffer); |
| glBufferData(GL_ARRAY_BUFFER, sizeof(vertexAttrs), vertexAttrs, |
| GL_STATIC_DRAW); |
| |
| glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), 0); |
| glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, |
| sizeof(VertexAttributes), |
| (GLvoid*)offsetof(VertexAttributes, color)); |
| |
| glEnableVertexAttribArray(0); |
| glEnableVertexAttribArray(1); |
| |
| glUseProgram(program); |
| |
| glClearColor(0.2f, 0.2f, 0.3f, 0.0f); |
| glViewport(0, 0, 1, 1); |
| |
| float matrix[16] = { |
| 1.0f, 0.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 0.0f, 1.0f, |
| }; |
| |
| glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
| |
| uint32_t uploadCount = 0; |
| static constexpr uint32_t kUploadLimit = 8000000; |
| |
| auto cpuTimeStart = System::cpuTime(); |
| |
| while (uploadCount < kUploadLimit) { |
| glUniformMatrix4fv(transformLoc, 1, GL_FALSE, matrix); |
| ++uploadCount; |
| } |
| |
| // Need a round trip at the end to get an accurate measurement |
| glFinish(); |
| |
| auto cpuTime = System::cpuTime() - cpuTimeStart; |
| |
| uint64_t duration_us = cpuTime.wall_time_us; |
| uint64_t duration_cpu_us = cpuTime.usageUs(); |
| |
| float ms = duration_us / 1000.0f; |
| float sec = duration_us / 1000000.0f; |
| |
| float drawCallHz = kUploadLimit / sec; |
| |
| glBindBuffer(GL_ARRAY_BUFFER, 0); |
| glDeleteBuffers(1, &buffer); |
| glUseProgram(0); |
| glDeleteProgram(program); |
| |
| printf("glUniformMatrix4fv %u times in %f ms. Rate: %f Hz\n", kUploadLimit, ms, |
| drawCallHz); |
| |
| android::perflogger::logDrawCallOverheadTest( |
| (const char*)glGetString(GL_VENDOR), |
| (const char*)glGetString(GL_RENDERER), |
| (const char*)glGetString(GL_VERSION), |
| "uniformUpload", "fullStack", |
| kUploadLimit, |
| (long)drawCallHz, |
| duration_us, |
| duration_cpu_us); |
| } |
| |
| TEST_F(CombinedGoldfishOpenglTest, AndroidHardwareBuffer) { |
| uint64_t usage = |
| AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | |
| AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | |
| AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN; |
| uint64_t cpuUsage = |
| AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | |
| AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN; |
| |
| AHardwareBuffer_Desc desc = { |
| kWindowSize, kWindowSize, 1, |
| AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM, |
| usage, |
| 4, // stride ignored for allocate; don't check this |
| }; |
| |
| AHardwareBuffer* buf; |
| AHardwareBuffer_allocate(&desc, &buf); |
| |
| AHardwareBuffer_Desc outDesc; |
| AHardwareBuffer_describe(buf, &outDesc); |
| |
| EXPECT_EQ(desc.width, outDesc.width); |
| EXPECT_EQ(desc.height, outDesc.height); |
| EXPECT_EQ(desc.layers, outDesc.layers); |
| EXPECT_EQ(desc.format, outDesc.format); |
| EXPECT_EQ(desc.usage, outDesc.usage); |
| |
| void* outVirtualAddress; |
| |
| ARect rect = { 0, 0, kWindowSize, kWindowSize, }; |
| |
| EXPECT_EQ(0, AHardwareBuffer_lock( |
| buf, cpuUsage, -1, &rect, &outVirtualAddress)); |
| EXPECT_EQ(0, AHardwareBuffer_unlock(buf, nullptr)); |
| |
| AHardwareBuffer_release(buf); |
| } |
