mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-19 07:51:57 +09:00
Merge magma-validate: Magma SPIR-V validation declines and surfaceless EGL.
This commit is contained in:
@@ -135,6 +135,51 @@ TEST(EGLStateProfile, CompatibilityProfileRequiresExplicitCompatBit) {
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_SUCCESS);
|
||||
}
|
||||
|
||||
// What `eglinfo -B` does for every API: eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)
|
||||
// (EGL_KHR_surfaceless_context). It used to be EGL_BAD_MATCH, so eglinfo printed the EGL lines and
|
||||
// no GL renderer/version lines at all. The binding records no surface: a client asking for the
|
||||
// current surface must see what it bound.
|
||||
TEST(EGLStateMakeCurrent, SurfacelessBindIsAcceptedAndRecordsNoSurface) {
|
||||
auto fixture = CreateFixture();
|
||||
EXPECT_TRUE(fixture->State.MakeCurrent(fixture->Display, EGL_NO_SURFACE, EGL_NO_SURFACE, fixture->Context));
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_SUCCESS);
|
||||
EXPECT_EQ(fixture->State.GetCurrentContext(), fixture->Context);
|
||||
EXPECT_EQ(fixture->State.GetCurrentSurface(EGL_DRAW), EGL_NO_SURFACE);
|
||||
EXPECT_EQ(fixture->State.GetCurrentSurface(EGL_READ), EGL_NO_SURFACE);
|
||||
EXPECT_TRUE(fixture->State.MakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
|
||||
}
|
||||
|
||||
// The extension relaxes only the both-absent case: one surface without the other stays a mismatch.
|
||||
TEST(EGLStateMakeCurrent, OneSidedSurfaceIsStillAMismatch) {
|
||||
auto fixture = CreateFixture();
|
||||
EXPECT_FALSE(fixture->State.MakeCurrent(fixture->Display, fixture->Surface, EGL_NO_SURFACE, fixture->Context));
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_BAD_MATCH);
|
||||
EXPECT_FALSE(fixture->State.MakeCurrent(fixture->Display, EGL_NO_SURFACE, fixture->Surface, fixture->Context));
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_BAD_MATCH);
|
||||
}
|
||||
|
||||
// eglinfo's ES probe chooses with EGL_RENDERABLE_TYPE/EGL_CONFORMANT = EGL_OPENGL_ES_BIT (ES 1.x),
|
||||
// which no MobileGL config claims, so it passes the NULL config on to eglCreateContext - legal
|
||||
// with EGL_KHR_no_config_context, where it means "no config". Without it that was
|
||||
// EGL_BAD_CONFIG and the "OpenGL ES profile" lines never printed.
|
||||
TEST(EGLStateCreateContext, NoConfigContextIsAcceptedAndReportsConfigIdZero) {
|
||||
auto fixture = CreateFixture();
|
||||
const EGLint esAttribs[] = {EGL_CONTEXT_MAJOR_VERSION, 3, EGL_NONE};
|
||||
const auto context = fixture->State.CreateContext(fixture->Display, EGL_NO_CONFIG_KHR, EGL_NO_CONTEXT, esAttribs);
|
||||
ASSERT_NE(context, EGL_NO_CONTEXT);
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_SUCCESS);
|
||||
EGLint configId = -1;
|
||||
EXPECT_TRUE(fixture->State.QueryContext(fixture->Display, context, EGL_CONFIG_ID, &configId));
|
||||
EXPECT_EQ(configId, 0);
|
||||
EXPECT_TRUE(fixture->State.MakeCurrent(fixture->Display, EGL_NO_SURFACE, EGL_NO_SURFACE, context));
|
||||
EXPECT_TRUE(fixture->State.MakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
|
||||
// A non-null handle that names no config is still EGL_BAD_CONFIG.
|
||||
EXPECT_EQ(fixture->State.CreateContext(fixture->Display, reinterpret_cast<EGLConfig>(0xdead), EGL_NO_CONTEXT,
|
||||
esAttribs),
|
||||
EGL_NO_CONTEXT);
|
||||
EXPECT_EQ(fixture->State.ConsumeError(), EGL_BAD_CONFIG);
|
||||
}
|
||||
|
||||
namespace {
|
||||
constexpr EGLAttrib kAbgr8888 = StateContext::kDrmFourccAbgr8888;
|
||||
constexpr EGLAttrib kXbgr8888 = StateContext::kDrmFourccXbgr8888;
|
||||
|
||||
@@ -5,6 +5,7 @@ add_executable(
|
||||
PipelineQuirkTest.cpp
|
||||
PassthroughTessControlTest.cpp
|
||||
ViewportIndexReflectionTest.cpp
|
||||
DriverModuleScreenTest.cpp
|
||||
)
|
||||
|
||||
target_include_directories(PipelineQuirkTest PRIVATE
|
||||
|
||||
@@ -0,0 +1,183 @@
|
||||
// MobileGL - MobileGL/MG_Test/Pipeline/DriverModuleScreenTest.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
//
|
||||
// ProgramFactory::ScreenModuleForDriver is the last look Magma takes at a module's bytes before
|
||||
// vkCreateShaderModule. A driver is not a validating entry point: a module that carried a sampler
|
||||
// inside the default uniform block (a frontend translation defect) was accepted by Adreno, which
|
||||
// then page-faulted on a descriptor read out of uniform-buffer bytes and lost the device. The
|
||||
// screen used to report such a module and hand it over anyway; it must DECLINE it, so the GPU
|
||||
// never sees it, unless MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV asks otherwise.
|
||||
//
|
||||
// The invalid module here is that exact shape, assembled by hand so it stays invalid whatever
|
||||
// the frontend does: a Block-decorated uniform struct with a sampled-image member.
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdio>
|
||||
|
||||
#include "Includes.h"
|
||||
#include "Init.h"
|
||||
|
||||
#include <MG_Backend/DirectVulkan/Renderer/ProgramFactory.h>
|
||||
#include <MG_Util/ShaderTranspiler/ShaderCompiler.h>
|
||||
#include <MG_Util/ShaderTranspiler/Types.h>
|
||||
|
||||
#include "spirv-tools/libspirv.hpp"
|
||||
|
||||
using namespace MobileGL;
|
||||
using MobileGL::MG_Backend::DirectVulkan::ProgramFactory;
|
||||
using Verdict = ProgramFactory::DriverModuleVerdict;
|
||||
|
||||
namespace {
|
||||
|
||||
// Shared by both modules: a fragment shader whose default uniform block holds a vec4 and,
|
||||
// in the invalid one, a sampler2D next to it.
|
||||
String UniformBlockFragment(Bool withSampler) {
|
||||
String text =
|
||||
"OpCapability Shader\n"
|
||||
"OpMemoryModel Logical GLSL450\n"
|
||||
"OpEntryPoint Fragment %main \"main\" %out\n"
|
||||
"OpExecutionMode %main OriginUpperLeft\n"
|
||||
"OpDecorate %out Location 0\n"
|
||||
"OpDecorate %Block Block\n"
|
||||
"OpMemberDecorate %Block 0 Offset 0\n"
|
||||
"OpDecorate %ubo DescriptorSet 0\n"
|
||||
"OpDecorate %ubo Binding 0\n"
|
||||
"%void = OpTypeVoid\n"
|
||||
"%fn = OpTypeFunction %void\n"
|
||||
"%float = OpTypeFloat 32\n"
|
||||
"%v4 = OpTypeVector %float 4\n"
|
||||
"%int = OpTypeInt 32 1\n"
|
||||
"%zero = OpConstant %int 0\n"
|
||||
"%img = OpTypeImage %float 2D 0 0 0 1 Unknown\n"
|
||||
"%simg = OpTypeSampledImage %img\n";
|
||||
text += withSampler ? "%Block = OpTypeStruct %v4 %simg\n" : "%Block = OpTypeStruct %v4\n";
|
||||
text +=
|
||||
"%pBlock = OpTypePointer Uniform %Block\n"
|
||||
"%ubo = OpVariable %pBlock Uniform\n"
|
||||
"%pv4u = OpTypePointer Uniform %v4\n"
|
||||
"%pv4o = OpTypePointer Output %v4\n"
|
||||
"%out = OpVariable %pv4o Output\n"
|
||||
"%main = OpFunction %void None %fn\n"
|
||||
"%entry = OpLabel\n"
|
||||
"%ptr = OpAccessChain %pv4u %ubo %zero\n"
|
||||
"%color = OpLoad %v4 %ptr\n"
|
||||
"OpStore %out %color\n"
|
||||
"OpReturn\n"
|
||||
"OpFunctionEnd\n";
|
||||
return text;
|
||||
}
|
||||
|
||||
Vector<Uint> Assemble(const String& text) {
|
||||
spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1);
|
||||
std::vector<uint32_t> words;
|
||||
EXPECT_TRUE(tools.Assemble(text, &words)) << text;
|
||||
return Vector<Uint>(words.begin(), words.end());
|
||||
}
|
||||
|
||||
// A realistic module out of the real frontend, for the cost measurement.
|
||||
Vector<Uint> CompileFragment(const String& source) {
|
||||
using namespace MG_Util::ShaderTranspiler;
|
||||
ShaderAttrib shaderAttrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = source};
|
||||
auto shaderResult = ShaderCompiler::CompileShader(shaderAttrib);
|
||||
EXPECT_TRUE(shaderResult) << (shaderResult ? String{} : shaderResult.error().log);
|
||||
if (!shaderResult) return {};
|
||||
ProgramAttrib programAttrib{.shaders = {shaderResult.value()}};
|
||||
auto programResult = ShaderCompiler::LinkProgram(programAttrib);
|
||||
EXPECT_TRUE(programResult) << (programResult ? String{} : programResult.error().log);
|
||||
if (!programResult) return {};
|
||||
ProgramBinaryAttrib binaryAttrib{.shaderTypes = {GL_FRAGMENT_SHADER}, .program = *programResult.value()};
|
||||
auto binaryResult = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
|
||||
if (!binaryResult || binaryResult->empty()) return {};
|
||||
const auto& words = binaryResult->front();
|
||||
return Vector<Uint>(words.begin(), words.end());
|
||||
}
|
||||
|
||||
class DriverModuleScreenTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override { MobileGL::Initialize(); }
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
// The headline: the sampler-in-uniform-block module never reaches the driver. Red before the
|
||||
// screen acted on its verdict - it answered AdmittedInvalid, i.e. "logged, handed over anyway".
|
||||
TEST_F(DriverModuleScreenTest, ASamplerInsideTheDefaultUniformBlockIsDeclined) {
|
||||
const Vector<Uint> invalid = Assemble(UniformBlockFragment(/*withSampler=*/true));
|
||||
ASSERT_FALSE(invalid.empty());
|
||||
String reason;
|
||||
EXPECT_EQ(ProgramFactory::ScreenModuleForDriver(invalid, /*allowInvalid=*/false, &reason),
|
||||
Verdict::DeclinedInvalid);
|
||||
EXPECT_FALSE(reason.empty()) << "a decline must carry the validator's reason for its log line";
|
||||
}
|
||||
|
||||
// The positive control: the same block without the sampler validates and is handed over. A screen
|
||||
// that declined everything would pass the case above and fail this one.
|
||||
TEST_F(DriverModuleScreenTest, TheSameBlockWithoutTheSamplerPasses) {
|
||||
const Vector<Uint> valid = Assemble(UniformBlockFragment(/*withSampler=*/false));
|
||||
ASSERT_FALSE(valid.empty());
|
||||
String reason = "stale";
|
||||
EXPECT_EQ(ProgramFactory::ScreenModuleForDriver(valid, /*allowInvalid=*/false, &reason), Verdict::Valid);
|
||||
EXPECT_TRUE(reason.empty());
|
||||
}
|
||||
|
||||
// The escape hatch: with MOBILEGL_MAGMA_ALLOW_INVALID_SPIRV the invalid module is handed over,
|
||||
// and the verdict says it was invalid rather than pretending it validated.
|
||||
TEST_F(DriverModuleScreenTest, TheEscapeHatchAdmitsAnInvalidModuleAndSaysSo) {
|
||||
const Vector<Uint> invalid = Assemble(UniformBlockFragment(/*withSampler=*/true));
|
||||
EXPECT_EQ(ProgramFactory::ScreenModuleForDriver(invalid, /*allowInvalid=*/true), Verdict::AdmittedInvalid);
|
||||
const Vector<Uint> valid = Assemble(UniformBlockFragment(/*withSampler=*/false));
|
||||
EXPECT_EQ(ProgramFactory::ScreenModuleForDriver(valid, /*allowInvalid=*/true), Verdict::Valid);
|
||||
}
|
||||
|
||||
// The verdict is remembered by content: re-screening the same bytes does not run spirv-val again,
|
||||
// and a different module does. Also reports what one validation costs next to a cached answer.
|
||||
TEST_F(DriverModuleScreenTest, TheVerdictIsCachedPerModuleContent) {
|
||||
const Vector<Uint> module = CompileFragment(R"(#version 330 core
|
||||
uniform sampler2D tex0;
|
||||
uniform sampler2D tex1;
|
||||
uniform vec4 tint;
|
||||
uniform mat4 colorMatrix;
|
||||
in vec2 uv;
|
||||
in vec4 vertexColor;
|
||||
out vec4 fragColor;
|
||||
vec3 tonemap(vec3 c) { return c / (c + vec3(1.0)); }
|
||||
void main() {
|
||||
vec4 base = texture(tex0, uv) * vertexColor;
|
||||
vec4 detail = texture(tex1, uv * 4.0);
|
||||
vec4 c = colorMatrix * mix(base, base * detail, 0.5) * tint;
|
||||
for (int i = 0; i < 4; ++i) c.rgb += 0.01 * sin(c.gbr * float(i + 1));
|
||||
fragColor = vec4(tonemap(c.rgb), c.a);
|
||||
}
|
||||
)");
|
||||
ASSERT_FALSE(module.empty());
|
||||
// A copy with one changed word in the bound field of the header: different bytes, same
|
||||
// validity, so it must miss the cache.
|
||||
Vector<Uint> sibling = module;
|
||||
sibling[3] += 1;
|
||||
|
||||
const Uint64 runsBefore = ProgramFactory::DriverModuleValidatorRuns();
|
||||
const auto t0 = std::chrono::steady_clock::now();
|
||||
const Verdict first = ProgramFactory::ScreenModuleForDriver(module, false);
|
||||
const auto t1 = std::chrono::steady_clock::now();
|
||||
const Verdict second = ProgramFactory::ScreenModuleForDriver(module, false);
|
||||
const auto t2 = std::chrono::steady_clock::now();
|
||||
EXPECT_EQ(first, Verdict::Valid);
|
||||
EXPECT_EQ(second, first);
|
||||
EXPECT_EQ(ProgramFactory::DriverModuleValidatorRuns(), runsBefore + 1) << "the second screen re-validated";
|
||||
|
||||
EXPECT_EQ(ProgramFactory::ScreenModuleForDriver(sibling, false), Verdict::Valid);
|
||||
EXPECT_EQ(ProgramFactory::DriverModuleValidatorRuns(), runsBefore + 2) << "different bytes shared a verdict";
|
||||
|
||||
const auto us = [](auto a, auto b) {
|
||||
return static_cast<long long>(std::chrono::duration_cast<std::chrono::microseconds>(b - a).count());
|
||||
};
|
||||
std::printf("[ screen ] %zu-word module: validate %lld us, cached %lld us\n", module.size(), us(t0, t1),
|
||||
us(t1, t2));
|
||||
}
|
||||
@@ -67,6 +67,9 @@ if (NOT WIN32)
|
||||
# MOBILEGL_IPC_SURFACE=server against a display-less `--serve` supervisor. Both drive real peers
|
||||
# and (the second, and D8's case) the real server image, as PeerLatchTest does.
|
||||
list(APPEND MOBILEGL_WIRE_TESTS InProcessServerTest ServerOwnedSurfaceTest)
|
||||
# `eglinfo -B`'s per-API sequence (surfaceless make-current, the ES probe's NULL config) through
|
||||
# a real MobileGL client against a real `--serve` supervisor, as ServerOwnedSurfaceTest does.
|
||||
list(APPEND MOBILEGL_WIRE_TESTS EglInfoSequenceTest)
|
||||
# P14 S2 (docs/Disaggregated/design/11-state-ownership.md): several sessions in ONE process.
|
||||
# The in-process unix supervisor serves each session on its own control thread with its own
|
||||
# ServerSession/ServerLoop/PipeInputs block/latch domain/segment resolver; two SHM clients are
|
||||
@@ -99,6 +102,7 @@ foreach (test IN LISTS MOBILEGL_WIRE_TESTS)
|
||||
${MGL_ROOT}/3rdparty/flatbuffers/include
|
||||
)
|
||||
if (test STREQUAL "PeerLatchTest" OR test STREQUAL "InProcessServerTest" OR test STREQUAL "ServerOwnedSurfaceTest" OR
|
||||
test STREQUAL "EglInfoSequenceTest" OR
|
||||
test STREQUAL "AdoptTierStreamTest" OR test STREQUAL "MultiSessionTest" OR test STREQUAL "ServerProbeTest")
|
||||
# It builds records and a program archive by hand, so it reaches MG_Pipe and MG_State
|
||||
# the way the codec suites do. (P12's two server suites share PeerLatchTest's healthy
|
||||
@@ -128,7 +132,8 @@ foreach (test IN LISTS MOBILEGL_WIRE_TESTS)
|
||||
endif ()
|
||||
|
||||
if (test STREQUAL "ServerSpawnTest" OR test STREQUAL "PeerLatchTest" OR test STREQUAL "InProcessServerTest" OR
|
||||
test STREQUAL "ServerOwnedSurfaceTest" OR test STREQUAL "AdoptTierStreamTest" OR test STREQUAL "ServerProbeTest")
|
||||
test STREQUAL "ServerOwnedSurfaceTest" OR test STREQUAL "EglInfoSequenceTest" OR test STREQUAL "AdoptTierStreamTest" OR
|
||||
test STREQUAL "ServerProbeTest")
|
||||
# It execs the real image, so it must be built first and must be told
|
||||
# where it is. MOBILEGL_TEST_SERVER_PATH is read by the test's
|
||||
# ServerImage() helper; without it the test would depend on the working
|
||||
|
||||
@@ -0,0 +1,276 @@
|
||||
// MobileGL - MobileGL/MG_Test/Wire/EglInfoSequenceTest.cpp
|
||||
// Copyright (c) 2025-2026 MobileGL-Dev
|
||||
// Licensed under the GNU Lesser General Public License v3.0:
|
||||
// https://www.gnu.org/licenses/gpl-3.0.txt
|
||||
// https://www.gnu.org/licenses/lgpl-3.0.txt
|
||||
// SPDX-License-Identifier: LGPL-3.0-only
|
||||
// End of Source File Header
|
||||
|
||||
// `eglinfo -B` AGAINST MOBILEGL, END TO END ON THE HOST: a real MobileGL client (the EGL entry
|
||||
// points, the spawn/tcp session) against a real `--serve` supervisor, driven through the exact call
|
||||
// sequence the distribution's eglinfo runs per display:
|
||||
//
|
||||
// eglInitialize; EGL_CLIENT_APIS must name "OpenGL" / "OpenGL_ES"; EGL_KHR_create_context decides
|
||||
// the attribute form. Then, per API:
|
||||
// eglBindAPI(api)
|
||||
// eglChooseConfig({EGL_CONFORMANT, bit, EGL_RED/GREEN/BLUE/ALPHA_SIZE 1, EGL_RENDERABLE_TYPE,
|
||||
// bit}) and take configs[0], or NULL when nothing matched
|
||||
// desktop: eglCreateContext({MAJOR, MINOR, PROFILE_MASK}) from 4.6 down (core stops at 3.1)
|
||||
// ES: eglCreateContext({EGL_CONTEXT_MAJOR_VERSION, n}) for n = 3, 2, 1
|
||||
// eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx) - surfaceless
|
||||
// glGetString(GL_VENDOR / GL_RENDERER / GL_VERSION) through eglGetProcAddress
|
||||
//
|
||||
// On the device eglinfo printed MobileGL's EGL lines for every platform and no GL lines at all. Two
|
||||
// refusals, both red here before the fix:
|
||||
// * the surfaceless eglMakeCurrent was EGL_BAD_MATCH, so no desktop context ever became current;
|
||||
// * the ES probe's bit is EGL_OPENGL_ES_BIT (ES 1.x), which no MobileGL config claims, so the
|
||||
// config is NULL and eglCreateContext answered EGL_BAD_CONFIG.
|
||||
|
||||
#include "P12ServerRig.h"
|
||||
|
||||
#include <MG_Impl/EGLImpl/EGLImpl.h>
|
||||
|
||||
using namespace MobileGL;
|
||||
using namespace P12;
|
||||
|
||||
namespace {
|
||||
|
||||
namespace EGL = MobileGL::MG_Impl::EGLImpl;
|
||||
|
||||
constexpr unsigned kGlVendor = 0x1F00;
|
||||
constexpr unsigned kGlRenderer = 0x1F01;
|
||||
constexpr unsigned kGlVersion = 0x1F02;
|
||||
|
||||
// One "OpenGL ... profile" block of eglinfo's output, or why it is missing.
|
||||
struct ProfileReport {
|
||||
Int32 configFound = 0; // eglChooseConfig matched something
|
||||
Int32 created = 0; // some eglCreateContext in the version walk returned a context
|
||||
Int32 madeCurrent = 0; // ...and the surfaceless eglMakeCurrent took it
|
||||
Int32 lastError = 0; // eglGetError after the last failed create / make-current
|
||||
Int32 drawIsNone = 0; // eglGetCurrentSurface(EGL_DRAW) == EGL_NO_SURFACE while current
|
||||
Int32 major = 0;
|
||||
Int32 minor = 0;
|
||||
char vendor[96] = {};
|
||||
char renderer[96] = {};
|
||||
char version[96] = {};
|
||||
};
|
||||
|
||||
struct EglInfoReport {
|
||||
Int32 initialized = 0;
|
||||
Int32 eglMajor = 0;
|
||||
Int32 eglMinor = 0;
|
||||
Int32 hasOpenGL = 0;
|
||||
Int32 hasOpenGLES = 0;
|
||||
Int32 khrCreateContext = 0;
|
||||
Int32 surfacelessExtensions = 0; // EGL_KHR_surfaceless_context and EGL_KHR_no_config_context advertised
|
||||
ProfileReport core{};
|
||||
ProfileReport compat{};
|
||||
ProfileReport es{};
|
||||
char note[128] = {};
|
||||
};
|
||||
|
||||
// eglinfo's extension_supported(): a whole space-separated token.
|
||||
bool HasToken(const char* list, const char* token) {
|
||||
if (list == nullptr) return false;
|
||||
const std::string all = std::string(" ") + list + " ";
|
||||
return all.find(std::string(" ") + token + " ") != std::string::npos;
|
||||
}
|
||||
|
||||
EGLConfig ChooseLikeEglInfo(EGLDisplay dpy, EGLint apiBit, ProfileReport& out) {
|
||||
const EGLint attribs[] = {EGL_CONFORMANT, apiBit, EGL_RED_SIZE, 1, EGL_GREEN_SIZE, 1, EGL_BLUE_SIZE, 1,
|
||||
EGL_ALPHA_SIZE, 1, EGL_RENDERABLE_TYPE, apiBit, EGL_NONE};
|
||||
EGLConfig configs[64] = {};
|
||||
EGLint count = 0;
|
||||
(void)EGL::ChooseConfig(dpy, attribs, configs, 64, &count);
|
||||
out.configFound = count > 0 ? 1 : 0;
|
||||
return count > 0 ? configs[0] : nullptr;
|
||||
}
|
||||
|
||||
// eglinfo's doOneContext, minus the printing.
|
||||
void ReadStrings(ProfileReport& out) {
|
||||
using GetStringFn = const unsigned char* (*)(unsigned);
|
||||
const auto getString = reinterpret_cast<GetStringFn>(EGL::GetProcAddress("glGetString"));
|
||||
if (getString == nullptr) return;
|
||||
const auto copy = [&](unsigned name, char* into, size_t size) {
|
||||
const unsigned char* text = getString(name);
|
||||
std::snprintf(into, size, "%s", text != nullptr ? reinterpret_cast<const char*>(text) : "");
|
||||
};
|
||||
copy(kGlVendor, out.vendor, sizeof(out.vendor));
|
||||
copy(kGlRenderer, out.renderer, sizeof(out.renderer));
|
||||
copy(kGlVersion, out.version, sizeof(out.version));
|
||||
}
|
||||
|
||||
// Returns the context made current, or EGL_NO_CONTEXT - eglinfo's createEGLContext.
|
||||
EGLContext TryCurrent(EGLDisplay dpy, EGLConfig config, const EGLint* attribs, ProfileReport& out) {
|
||||
const EGLContext ctx = EGL::CreateContext(dpy, config, EGL_NO_CONTEXT, attribs);
|
||||
if (ctx == EGL_NO_CONTEXT) {
|
||||
out.lastError = EGL::GetError();
|
||||
return EGL_NO_CONTEXT;
|
||||
}
|
||||
out.created = 1;
|
||||
if (EGL::MakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx) != EGL_TRUE) {
|
||||
out.lastError = EGL::GetError();
|
||||
(void)EGL::DestroyContext(dpy, ctx);
|
||||
return EGL_NO_CONTEXT;
|
||||
}
|
||||
out.madeCurrent = 1;
|
||||
out.drawIsNone = EGL::GetCurrentSurface(EGL_DRAW) == EGL_NO_SURFACE ? 1 : 0;
|
||||
return ctx;
|
||||
}
|
||||
|
||||
void Release(EGLDisplay dpy, EGLContext ctx, ProfileReport& out) {
|
||||
ReadStrings(out);
|
||||
(void)EGL::MakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
||||
(void)EGL::DestroyContext(dpy, ctx);
|
||||
}
|
||||
|
||||
void DesktopProfile(EGLDisplay dpy, EGLConfig config, bool core, bool khrCreateContext, ProfileReport& out) {
|
||||
static const int kVersions[][2] = {{4, 6}, {4, 5}, {4, 4}, {4, 3}, {4, 2}, {4, 1}, {4, 0}, {3, 3},
|
||||
{3, 2}, {3, 1}, {3, 0}, {2, 1}, {2, 0}, {1, 5}, {1, 4}, {1, 3},
|
||||
{1, 2}, {1, 1}, {1, 0}};
|
||||
for (const auto& v : kVersions) {
|
||||
if (core && v[0] == 3 && v[1] == 0) return;
|
||||
const EGLint withProfile[] = {EGL_CONTEXT_MAJOR_VERSION, v[0], EGL_CONTEXT_MINOR_VERSION, v[1],
|
||||
EGL_CONTEXT_OPENGL_PROFILE_MASK,
|
||||
core ? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT
|
||||
: EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT,
|
||||
EGL_NONE};
|
||||
const EGLint old[] = {EGL_CONTEXT_CLIENT_VERSION, v[0], EGL_NONE};
|
||||
const EGLContext ctx = TryCurrent(dpy, config, khrCreateContext ? withProfile : old, out);
|
||||
if (ctx != EGL_NO_CONTEXT) {
|
||||
out.major = v[0];
|
||||
out.minor = v[1];
|
||||
Release(dpy, ctx, out);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void EsProfile(EGLDisplay dpy, EGLConfig config, ProfileReport& out) {
|
||||
for (int major = 3; major > 0; --major) {
|
||||
const EGLint attribs[] = {EGL_CONTEXT_MAJOR_VERSION, major, EGL_NONE};
|
||||
const EGLContext ctx = TryCurrent(dpy, config, attribs, out);
|
||||
if (ctx != EGL_NO_CONTEXT) {
|
||||
out.major = major;
|
||||
Release(dpy, ctx, out);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
EglInfoReport RunEglInfoPeer(const ServerProcess& server, const std::string& clientLogBase) {
|
||||
EglInfoReport report{};
|
||||
int fds[2] = {-1, -1};
|
||||
if (::pipe(fds) != 0) return report;
|
||||
std::fflush(nullptr);
|
||||
const pid_t pid = ::fork();
|
||||
if (pid == 0) {
|
||||
::close(fds[0]);
|
||||
::setenv("MOBILEGL_LOG_FILE_PATH", clientLogBase.c_str(), 1);
|
||||
::setenv("MOBILEGL_TRANSPORT", "spawn", 1);
|
||||
::setenv("MOBILEGL_IPC_CONTROL", server.endpoint.c_str(), 1);
|
||||
::setenv("MOBILEGL_BACKEND_TYPE", "DirectGLES", 1);
|
||||
::unsetenv("MOBILEGL_IPC_SURFACE");
|
||||
EglInfoReport r{};
|
||||
// eglinfo walks every platform; surfaceless is the one a display-less container has.
|
||||
const EGLDisplay dpy = EGL::GetPlatformDisplay(EGL_PLATFORM_SURFACELESS_MESA, EGL_DEFAULT_DISPLAY, nullptr);
|
||||
EGLint major = 0;
|
||||
EGLint minor = 0;
|
||||
if (dpy == EGL_NO_DISPLAY || EGL::Initialize(dpy, &major, &minor) != EGL_TRUE) {
|
||||
std::snprintf(r.note, sizeof(r.note), "eglInitialize failed (no spawn session?)");
|
||||
} else {
|
||||
r.initialized = 1;
|
||||
r.eglMajor = major;
|
||||
r.eglMinor = minor;
|
||||
const char* apis = EGL::QueryString(dpy, EGL_CLIENT_APIS);
|
||||
const char* exts = EGL::QueryString(dpy, EGL_EXTENSIONS);
|
||||
r.hasOpenGL = HasToken(apis, "OpenGL") ? 1 : 0;
|
||||
r.hasOpenGLES = HasToken(apis, "OpenGL_ES") ? 1 : 0;
|
||||
const bool khr = major == 1 && minor >= 4 && HasToken(exts, "EGL_KHR_create_context");
|
||||
r.khrCreateContext = khr ? 1 : 0;
|
||||
r.surfacelessExtensions =
|
||||
HasToken(exts, "EGL_KHR_surfaceless_context") && HasToken(exts, "EGL_KHR_no_config_context") ? 1 : 0;
|
||||
if (r.hasOpenGL && EGL::BindAPI(EGL_OPENGL_API) == EGL_TRUE) {
|
||||
const EGLConfig config = ChooseLikeEglInfo(dpy, EGL_OPENGL_BIT, r.core);
|
||||
r.compat.configFound = r.core.configFound;
|
||||
if (khr) DesktopProfile(dpy, config, /*core=*/true, khr, r.core);
|
||||
DesktopProfile(dpy, config, /*core=*/false, khr, r.compat);
|
||||
}
|
||||
if (r.hasOpenGLES && EGL::BindAPI(EGL_OPENGL_ES_API) == EGL_TRUE) {
|
||||
const EGLConfig config = ChooseLikeEglInfo(dpy, EGL_OPENGL_ES_BIT, r.es);
|
||||
EsProfile(dpy, config, r.es);
|
||||
}
|
||||
(void)EGL::Terminate(dpy);
|
||||
}
|
||||
const ssize_t wrote = ::write(fds[1], &r, sizeof(r));
|
||||
(void)wrote;
|
||||
std::fflush(nullptr);
|
||||
::_exit(0);
|
||||
}
|
||||
::close(fds[1]);
|
||||
if (pid < 0) {
|
||||
::close(fds[0]);
|
||||
return report;
|
||||
}
|
||||
pollfd pfd{fds[0], POLLIN, 0};
|
||||
if (::poll(&pfd, 1, 90000) > 0) {
|
||||
if (::read(fds[0], &report, sizeof(report)) != static_cast<ssize_t>(sizeof(report))) {
|
||||
report = EglInfoReport{};
|
||||
std::snprintf(report.note, sizeof(report.note), "peer died before reporting");
|
||||
}
|
||||
} else {
|
||||
std::snprintf(report.note, sizeof(report.note), "peer timed out");
|
||||
::kill(pid, SIGKILL);
|
||||
}
|
||||
::close(fds[0]);
|
||||
int status = 0;
|
||||
::waitpid(pid, &status, 0);
|
||||
return report;
|
||||
}
|
||||
|
||||
std::string Describe(const char* label, const ProfileReport& p) {
|
||||
char text[512];
|
||||
std::snprintf(text, sizeof(text),
|
||||
"%s: config=%d created=%d current=%d eglError=0x%04x version=%d.%d vendor='%s' renderer='%s' "
|
||||
"GL_VERSION='%s'",
|
||||
label, p.configFound, p.created, p.madeCurrent, p.lastError, p.major, p.minor, p.vendor,
|
||||
p.renderer, p.version);
|
||||
return text;
|
||||
}
|
||||
|
||||
void ExpectProfilePrinted(const char* label, const ProfileReport& p) {
|
||||
EXPECT_EQ(p.created, 1) << Describe(label, p);
|
||||
EXPECT_EQ(p.madeCurrent, 1) << "the surfaceless eglMakeCurrent was refused - " << Describe(label, p);
|
||||
EXPECT_EQ(p.drawIsNone, 1) << "a surfaceless binding reported a current draw surface - " << Describe(label, p);
|
||||
EXPECT_NE(p.renderer[0], '\0') << "no renderer line - " << Describe(label, p);
|
||||
EXPECT_NE(p.version[0], '\0') << "no version line - " << Describe(label, p);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(EglInfoSequence, EveryProfilePrintsItsRendererAndVersion) {
|
||||
ServerProcess server;
|
||||
ASSERT_TRUE(LaunchSupervisor("eglinfo", &server)) << server.Log();
|
||||
const std::string clientLog = "/tmp/mgl-eglinfo-client-" + std::to_string(::getpid()) + ".log";
|
||||
Debug::TruncateRoleLogs(clientLog.c_str());
|
||||
const EglInfoReport r = RunEglInfoPeer(server, clientLog);
|
||||
ASSERT_EQ(r.initialized, 1) << r.note;
|
||||
// eglinfo only takes the KHR_create_context attribute form on EGL >= 1.4 with the extension.
|
||||
EXPECT_EQ(r.khrCreateContext, 1) << "EGL " << r.eglMajor << "." << r.eglMinor;
|
||||
ASSERT_EQ(r.hasOpenGL, 1);
|
||||
ASSERT_EQ(r.hasOpenGLES, 1);
|
||||
EXPECT_EQ(r.surfacelessExtensions, 1) << "the display does not advertise what it now accepts";
|
||||
std::printf("[ eglinfo ] %s\n[ eglinfo ] %s\n[ eglinfo ] %s\n", Describe("core", r.core).c_str(),
|
||||
Describe("compat", r.compat).c_str(), Describe("es", r.es).c_str());
|
||||
if (r.core.madeCurrent == 1 && r.core.renderer[0] == '\0')
|
||||
GTEST_SKIP() << "the surfaceless binding was accepted; the strings need headless EGL on the server";
|
||||
ExpectProfilePrinted("OpenGL core profile", r.core);
|
||||
ExpectProfilePrinted("OpenGL compatibility profile", r.compat);
|
||||
ExpectProfilePrinted("OpenGL ES profile", r.es);
|
||||
std::error_code ec;
|
||||
if (!::testing::Test::HasFailure()) {
|
||||
std::filesystem::remove(Debug::RoleLogPath(clientLog.c_str(), Debug::LogRole::Client), ec);
|
||||
std::filesystem::remove(Debug::RoleLogPath(clientLog.c_str(), Debug::LogRole::Server), ec);
|
||||
std::filesystem::remove(clientLog, ec);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user