From 4cf2501c678dd960a693e2d4c39cf245bd87711e Mon Sep 17 00:00:00 2001 From: Peng Huang Date: Mon, 27 Jul 2020 13:19:27 -0400 Subject: [PATCH] Add extension EGL_ANGLE_display_semaphore_share_group For sharing semaphores globally. Bug: angleproject:4877 Change-Id: I472e0902fd04ca8350d74e6c0ae6925ee930ccf9 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2319370 Commit-Queue: Jamie Madill Reviewed-by: Shahbaz Youssefi Reviewed-by: Jamie Madill --- ...GL_ANGLE_display_semaphore_share_group.txt | 82 +++++++++++++++++++ include/EGL/eglext_angle.h | 5 ++ .../GL_EGL_WGL_loader.json | 4 +- .../GL_EGL_entry_points.json | 4 +- .../GLenum_value_to_string_map.json | 2 +- .../code_generation_hashes/proc_table.json | 4 +- scripts/egl.xml | 10 +++ scripts/registry_xml.py | 2 + src/libANGLE/Caps.cpp | 1 + src/libANGLE/Caps.h | 3 + src/libANGLE/Context.cpp | 8 ++ src/libANGLE/Context.h | 3 + src/libANGLE/Display.cpp | 45 ++++++++-- src/libANGLE/Display.h | 3 + src/libANGLE/FrameCapture.cpp | 2 +- src/libANGLE/State.cpp | 45 ++++------ src/libANGLE/State.h | 1 + .../renderer/d3d/d3d11/Renderer11.cpp | 5 +- src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp | 5 +- src/libANGLE/renderer/gl/cgl/DisplayCGL.mm | 5 +- src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm | 5 +- src/libANGLE/renderer/gl/egl/DisplayEGL.cpp | 5 +- src/libANGLE/renderer/gl/glx/DisplayGLX.cpp | 5 +- src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp | 5 +- src/libANGLE/renderer/vulkan/DisplayVk.cpp | 1 + src/libANGLE/validationEGL.cpp | 21 +++++ 26 files changed, 225 insertions(+), 56 deletions(-) create mode 100644 extensions/EGL_ANGLE_display_semaphore_share_group.txt diff --git a/extensions/EGL_ANGLE_display_semaphore_share_group.txt b/extensions/EGL_ANGLE_display_semaphore_share_group.txt new file mode 100644 index 000000000..40613718b --- /dev/null +++ b/extensions/EGL_ANGLE_display_semaphore_share_group.txt @@ -0,0 +1,82 @@ +Name + + ANGLE_display_semaphore_share_group + +Name Strings + + EGL_ANGLE_display_semaphore_share_group + +Contributors + + Peng Huang, Google + +Contacts + + Peng Huang, Google (penghuang 'at' google.com) + +Status + + Draft + +Version + + Version 1, July 27, 2020 + +Number + + EGL Extension TBD + +Dependencies + + This extension is written against the wording of the EGL 1.5 specification. + +Overview + + This extension allows for the creation of OpenGL ES contexts that share + semaphore objects with other contexts owned by the same display. This method + of sharing semaphores can be used in conjuction with regular share groups. + +New Types + + None + +New Procedures and Functions + + None + +New Tokens + + Accepted as an attribute name in the <*attrib_list> argument to + eglCreateContext: + + EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE 0x348D + +Additions to the EGL 1.5 Specification + + Add a new section entitled "OpenGL ES Global Semaphore Share Groups" + to section 3.7.1: + + "If the attribute EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE is set to EGL_TRUE, + a context that shares semaphores with other contexts owned by the same + display and created with EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE set to + EGL_TRUE will be created. If the share_context parameter to + eglCreateContext is not NULL, all contexts within the share group must have + been created with the same value of EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE. + The default value of EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE is EGL_FALSE." + +Issues + + (1) What happens to the shared semaphores when a context in the global share + group is destroyed? + + RESOLOVED: When the last context in the global semaphore share group is + destroyed, all semaphores in the global semaphore share group are released. If + a new context is created in the global semaphore share group, no semaphores + will exist. + + This mirrors how regular share groups work, releasing all objects when the + last context is destroyed. + +Revision History + + Version 1, 2020/07/27 - first draft. diff --git a/include/EGL/eglext_angle.h b/include/EGL/eglext_angle.h index 4702d95a4..b5b669521 100644 --- a/include/EGL/eglext_angle.h +++ b/include/EGL/eglext_angle.h @@ -319,6 +319,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithFrameTokenANGLE(EGLDisplay dpy, #define EGL_EAGL_CONTEXT_ANGLE 0x348C #endif +#ifndef EGL_ANGLE_display_semaphore_share_group +#define EGL_ANGLE_display_semaphore_share_group 1 +#define EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE 0x348D +#endif /* EGL_ANGLE_display_semaphore_share_group */ + // clang-format on #endif // INCLUDE_EGL_EGLEXT_ANGLE_ diff --git a/scripts/code_generation_hashes/GL_EGL_WGL_loader.json b/scripts/code_generation_hashes/GL_EGL_WGL_loader.json index fb9dddabc..2a6c55ce8 100644 --- a/scripts/code_generation_hashes/GL_EGL_WGL_loader.json +++ b/scripts/code_generation_hashes/GL_EGL_WGL_loader.json @@ -1,6 +1,6 @@ { "scripts/egl.xml": - "842e24514c4cfe09fba703c17a0fd292", + "4e5911cfe91274cc5112ff2f70092376", "scripts/egl_angle_ext.xml": "087d6a3996a91fbb0b664cac57c50c4c", "scripts/generate_loader.py": @@ -10,7 +10,7 @@ "scripts/gl_angle_ext.xml": "079cc4829de7ce638faf7bbf66e141ad", "scripts/registry_xml.py": - "f45ffbc8a3c8a7144c2e98e19d1127a0", + "5d9874e9e53bde1f644808dbab945578", "scripts/wgl.xml": "aa96419c582af2f6673430e2847693f4", "src/libEGL/egl_loader_autogen.cpp": diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json index fb6ebeb13..c2067300e 100644 --- a/scripts/code_generation_hashes/GL_EGL_entry_points.json +++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json @@ -1,6 +1,6 @@ { "scripts/egl.xml": - "842e24514c4cfe09fba703c17a0fd292", + "4e5911cfe91274cc5112ff2f70092376", "scripts/egl_angle_ext.xml": "087d6a3996a91fbb0b664cac57c50c4c", "scripts/entry_point_packed_gl_enums.json": @@ -12,7 +12,7 @@ "scripts/gl_angle_ext.xml": "079cc4829de7ce638faf7bbf66e141ad", "scripts/registry_xml.py": - "f45ffbc8a3c8a7144c2e98e19d1127a0", + "5d9874e9e53bde1f644808dbab945578", "scripts/wgl.xml": "aa96419c582af2f6673430e2847693f4", "src/libANGLE/Context_gl_1_0_autogen.h": diff --git a/scripts/code_generation_hashes/GLenum_value_to_string_map.json b/scripts/code_generation_hashes/GLenum_value_to_string_map.json index 3eb8bf728..63cd7094a 100644 --- a/scripts/code_generation_hashes/GLenum_value_to_string_map.json +++ b/scripts/code_generation_hashes/GLenum_value_to_string_map.json @@ -6,7 +6,7 @@ "scripts/gl_angle_ext.xml": "079cc4829de7ce638faf7bbf66e141ad", "scripts/registry_xml.py": - "f45ffbc8a3c8a7144c2e98e19d1127a0", + "5d9874e9e53bde1f644808dbab945578", "src/libANGLE/gl_enum_utils_autogen.cpp": "48627c0865d15bf4014327de5858d3c5", "src/libANGLE/gl_enum_utils_autogen.h": diff --git a/scripts/code_generation_hashes/proc_table.json b/scripts/code_generation_hashes/proc_table.json index cf9d75013..97627a998 100644 --- a/scripts/code_generation_hashes/proc_table.json +++ b/scripts/code_generation_hashes/proc_table.json @@ -1,6 +1,6 @@ { "scripts/egl.xml": - "842e24514c4cfe09fba703c17a0fd292", + "4e5911cfe91274cc5112ff2f70092376", "scripts/egl_angle_ext.xml": "087d6a3996a91fbb0b664cac57c50c4c", "scripts/gen_proc_table.py": @@ -10,7 +10,7 @@ "scripts/gl_angle_ext.xml": "079cc4829de7ce638faf7bbf66e141ad", "scripts/registry_xml.py": - "f45ffbc8a3c8a7144c2e98e19d1127a0", + "5d9874e9e53bde1f644808dbab945578", "scripts/wgl.xml": "aa96419c582af2f6673430e2847693f4", "src/libGL/proc_table_wgl_autogen.cpp": diff --git a/scripts/egl.xml b/scripts/egl.xml index ab0a6518b..157372ce3 100644 --- a/scripts/egl.xml +++ b/scripts/egl.xml @@ -2132,6 +2132,16 @@ + + + + + + + + + + diff --git a/scripts/registry_xml.py b/scripts/registry_xml.py index 3d1f2347b..41b8382c9 100644 --- a/scripts/registry_xml.py +++ b/scripts/registry_xml.py @@ -124,6 +124,8 @@ supported_egl_extensions = [ "EGL_ANGLE_d3d_share_handle_client_buffer", "EGL_ANGLE_device_creation", "EGL_ANGLE_device_d3d", + "EGL_ANGLE_display_semaphore_share_group", + "EGL_ANGLE_display_texture_share_group", "EGL_ANGLE_feature_control", "EGL_ANGLE_ggp_stream_descriptor", "EGL_ANGLE_power_preference", diff --git a/src/libANGLE/Caps.cpp b/src/libANGLE/Caps.cpp index d150fb901..50f214162 100644 --- a/src/libANGLE/Caps.cpp +++ b/src/libANGLE/Caps.cpp @@ -1371,6 +1371,7 @@ std::vector DisplayExtensions::getStrings() const InsertExtensionString("EGL_EXT_pixel_format_float", pixelFormatFloat, &extensionStrings); InsertExtensionString("EGL_KHR_surfaceless_context", surfacelessContext, &extensionStrings); InsertExtensionString("EGL_ANGLE_display_texture_share_group", displayTextureShareGroup, &extensionStrings); + InsertExtensionString("EGL_ANGLE_display_semaphore_share_group", displaySemaphoreShareGroup, &extensionStrings); InsertExtensionString("EGL_ANGLE_create_context_client_arrays", createContextClientArrays, &extensionStrings); InsertExtensionString("EGL_ANGLE_program_cache_control", programCacheControl, &extensionStrings); InsertExtensionString("EGL_ANGLE_robust_resource_initialization", robustResourceInitialization, &extensionStrings); diff --git a/src/libANGLE/Caps.h b/src/libANGLE/Caps.h index 3713abad2..140d5c156 100644 --- a/src/libANGLE/Caps.h +++ b/src/libANGLE/Caps.h @@ -996,6 +996,9 @@ struct DisplayExtensions // EGL_ANGLE_display_texture_share_group bool displayTextureShareGroup = false; + // EGL_ANGLE_display_semaphore_share_group + bool displaySemaphoreShareGroup = false; + // EGL_ANGLE_create_context_client_arrays bool createContextClientArrays = false; diff --git a/src/libANGLE/Context.cpp b/src/libANGLE/Context.cpp index 4a4aeef19..b12e619ab 100644 --- a/src/libANGLE/Context.cpp +++ b/src/libANGLE/Context.cpp @@ -276,6 +276,7 @@ Context::Context(egl::Display *display, const egl::Config *config, const Context *shareContext, TextureManager *shareTextures, + SemaphoreManager *shareSemaphores, MemoryProgramCache *memoryProgramCache, const EGLenum clientType, const egl::AttributeMap &attribs, @@ -284,6 +285,7 @@ Context::Context(egl::Display *display, : mState(shareContext ? &shareContext->mState : nullptr, AllocateOrGetShareGroup(display, shareContext), shareTextures, + shareSemaphores, &mOverlay, clientType, GetClientVersion(display, attribs), @@ -296,6 +298,7 @@ Context::Context(egl::Display *display, mShared(shareContext != nullptr), mSkipValidation(GetNoError(attribs)), mDisplayTextureShareGroup(shareTextures != nullptr), + mDisplaySemaphoreShareGroup(shareSemaphores != nullptr), mErrors(this), mImplementation(display->getImplementation() ->createContext(mState, &mErrors, config, shareContext, attribs)), @@ -8059,6 +8062,11 @@ bool Context::usingDisplayTextureShareGroup() const return mDisplayTextureShareGroup; } +bool Context::usingDisplaySemaphoreShareGroup() const +{ + return mDisplaySemaphoreShareGroup; +} + GLenum Context::getConvertedRenderbufferFormat(GLenum internalformat) const { if (mState.mExtensions.webglCompatibility && mState.mClientVersion.major == 2 && diff --git a/src/libANGLE/Context.h b/src/libANGLE/Context.h index 616865d09..0cf21d586 100644 --- a/src/libANGLE/Context.h +++ b/src/libANGLE/Context.h @@ -351,6 +351,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl const egl::Config *config, const Context *shareContext, TextureManager *shareTextures, + SemaphoreManager *shareSemaphores, MemoryProgramCache *memoryProgramCache, const EGLenum clientType, const egl::AttributeMap &attribs, @@ -575,6 +576,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl bool isQueryGenerated(QueryID query) const; bool usingDisplayTextureShareGroup() const; + bool usingDisplaySemaphoreShareGroup() const; // Hack for the special WebGL 1 "DEPTH_STENCIL" internal format. GLenum getConvertedRenderbufferFormat(GLenum internalformat) const; @@ -679,6 +681,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl bool mShared; bool mSkipValidation; bool mDisplayTextureShareGroup; + bool mDisplaySemaphoreShareGroup; // Recorded errors ErrorSet mErrors; diff --git a/src/libANGLE/Display.cpp b/src/libANGLE/Display.cpp index e3ebe325d..172dfacc1 100644 --- a/src/libANGLE/Display.cpp +++ b/src/libANGLE/Display.cpp @@ -651,9 +651,11 @@ Display::Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDe mSurface(nullptr), mPlatform(platform), mTextureManager(nullptr), + mSemaphoreManager(nullptr), mBlobCache(gl::kDefaultMaxProgramCacheMemoryBytes), mMemoryProgramCache(mBlobCache), - mGlobalTextureShareGroupUsers(0) + mGlobalTextureShareGroupUsers(0), + mGlobalSemaphoreShareGroupUsers(0) {} Display::~Display() @@ -877,8 +879,10 @@ Error Display::terminate(const Thread *thread) ANGLE_TRY(makeCurrent(thread, nullptr, nullptr, nullptr)); - // The global texture manager should be deleted with the last context that uses it. + // The global texture and semaphore managers should be deleted with the last context that uses + // it. ASSERT(mGlobalTextureShareGroupUsers == 0 && mTextureManager == nullptr); + ASSERT(mGlobalSemaphoreShareGroupUsers == 0 && mSemaphoreManager == nullptr); while (!mImageSet.empty()) { @@ -1143,6 +1147,23 @@ Error Display::createContext(const Config *configuration, shareTextures = mTextureManager; } + // This display semaphore sharing will allow the first context to create the semaphore share + // group. + bool usingDisplaySemaphoreShareGroup = + attribs.get(EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE, EGL_FALSE) == EGL_TRUE; + gl::SemaphoreManager *shareSemaphores = nullptr; + if (usingDisplaySemaphoreShareGroup) + { + ASSERT((mSemaphoreManager == nullptr) == (mGlobalSemaphoreShareGroupUsers == 0)); + if (mSemaphoreManager == nullptr) + { + mSemaphoreManager = new gl::SemaphoreManager(); + } + + mGlobalSemaphoreShareGroupUsers++; + shareSemaphores = mSemaphoreManager; + } + gl::MemoryProgramCache *cachePointer = &mMemoryProgramCache; // Check context creation attributes to see if we are using EGL_ANGLE_program_cache_control. @@ -1162,9 +1183,9 @@ Error Display::createContext(const Config *configuration, } } - gl::Context *context = - new gl::Context(this, configuration, shareContext, shareTextures, cachePointer, clientType, - attribs, mDisplayExtensions, GetClientExtensions()); + gl::Context *context = new gl::Context(this, configuration, shareContext, shareTextures, + shareSemaphores, cachePointer, clientType, attribs, + mDisplayExtensions, GetClientExtensions()); if (shareContext != nullptr) { shareContext->setShared(); @@ -1329,6 +1350,20 @@ Error Display::destroyContext(const Thread *thread, gl::Context *context) mGlobalTextureShareGroupUsers--; } + if (context->usingDisplaySemaphoreShareGroup()) + { + ASSERT(mGlobalSemaphoreShareGroupUsers >= 1 && mSemaphoreManager != nullptr); + if (mGlobalSemaphoreShareGroupUsers == 1) + { + // If this is the last context using the global share group, destroy the global + // semaphore manager so that the semaphores can be destroyed while a context still + // exists + mSemaphoreManager->release(context); + mSemaphoreManager = nullptr; + } + mGlobalSemaphoreShareGroupUsers--; + } + ANGLE_TRY(context->onDestroy(this)); mContextSet.erase(context); SafeDelete(context); diff --git a/src/libANGLE/Display.h b/src/libANGLE/Display.h index 49dba916a..7e007d99d 100644 --- a/src/libANGLE/Display.h +++ b/src/libANGLE/Display.h @@ -32,6 +32,7 @@ namespace gl { class Context; class TextureManager; +class SemaphoreManager; } // namespace gl namespace rx @@ -302,9 +303,11 @@ class Display final : public LabeledObject, angle::LoggingAnnotator mAnnotator; gl::TextureManager *mTextureManager; + gl::SemaphoreManager *mSemaphoreManager; BlobCache mBlobCache; gl::MemoryProgramCache mMemoryProgramCache; size_t mGlobalTextureShareGroupUsers; + size_t mGlobalSemaphoreShareGroupUsers; angle::FrontendFeatures mFrontendFeatures; diff --git a/src/libANGLE/FrameCapture.cpp b/src/libANGLE/FrameCapture.cpp index 887c2f6b4..c15c8239a 100644 --- a/src/libANGLE/FrameCapture.cpp +++ b/src/libANGLE/FrameCapture.cpp @@ -2088,7 +2088,7 @@ void CaptureMidExecutionSetup(const gl::Context *context, FrameCapture *frameCapture) { const gl::State &apiState = context->getState(); - gl::State replayState(nullptr, nullptr, nullptr, nullptr, EGL_OPENGL_ES_API, + gl::State replayState(nullptr, nullptr, nullptr, nullptr, nullptr, EGL_OPENGL_ES_API, apiState.getClientVersion(), false, true, true, true, false, EGL_CONTEXT_PRIORITY_MEDIUM_IMG); diff --git a/src/libANGLE/State.cpp b/src/libANGLE/State.cpp index c3955f254..8fbaac768 100644 --- a/src/libANGLE/State.cpp +++ b/src/libANGLE/State.cpp @@ -72,43 +72,28 @@ template using ContextStateMember = T *(State::*); template -T *AllocateOrGetSharedResourceManager(const State *shareContextState, ContextStateMember member) +T *AllocateOrGetSharedResourceManager(const State *shareContextState, + ContextStateMember member, + T *shareResources = nullptr) { if (shareContextState) { T *resourceManager = (*shareContextState).*member; + ASSERT(!resourceManager || resourceManager == shareResources || !shareResources); resourceManager->addRef(); return resourceManager; } + else if (shareResources) + { + shareResources->addRef(); + return shareResources; + } else { return new T(); } } -TextureManager *AllocateOrGetSharedTextureManager(const State *shareContextState, - TextureManager *shareTextures, - ContextStateMember member) -{ - if (shareContextState) - { - TextureManager *textureManager = (*shareContextState).*member; - ASSERT(shareTextures == nullptr || textureManager == shareTextures); - textureManager->addRef(); - return textureManager; - } - else if (shareTextures) - { - TextureManager *textureManager = shareTextures; - textureManager->addRef(); - return textureManager; - } - else - { - return new TextureManager(); - } -} - // TODO(https://anglebug.com/3889): Remove this helper function after blink and chromium part // refactory done. bool IsTextureCompatibleWithSampler(TextureType texture, TextureType sampler) @@ -308,6 +293,7 @@ ANGLE_INLINE void ActiveTexturesCache::set(ContextID contextID, State::State(const State *shareContextState, egl::ShareGroup *shareGroup, TextureManager *shareTextures, + SemaphoreManager *shareSemaphores, const OverlayType *overlay, const EGLenum clientType, const Version &clientVersion, @@ -325,9 +311,9 @@ State::State(const State *shareContextState, mBufferManager(AllocateOrGetSharedResourceManager(shareContextState, &State::mBufferManager)), mShaderProgramManager( AllocateOrGetSharedResourceManager(shareContextState, &State::mShaderProgramManager)), - mTextureManager(AllocateOrGetSharedTextureManager(shareContextState, - shareTextures, - &State::mTextureManager)), + mTextureManager(AllocateOrGetSharedResourceManager(shareContextState, + &State::mTextureManager, + shareTextures)), mRenderbufferManager( AllocateOrGetSharedResourceManager(shareContextState, &State::mRenderbufferManager)), mSamplerManager( @@ -337,8 +323,9 @@ State::State(const State *shareContextState, mProgramPipelineManager(new ProgramPipelineManager()), mMemoryObjectManager( AllocateOrGetSharedResourceManager(shareContextState, &State::mMemoryObjectManager)), - mSemaphoreManager( - AllocateOrGetSharedResourceManager(shareContextState, &State::mSemaphoreManager)), + mSemaphoreManager(AllocateOrGetSharedResourceManager(shareContextState, + &State::mSemaphoreManager, + shareSemaphores)), mMaxDrawBuffers(0), mMaxCombinedTextureImageUnits(0), mDepthClearValue(0), diff --git a/src/libANGLE/State.h b/src/libANGLE/State.h index d8c2e48ae..92426b857 100644 --- a/src/libANGLE/State.h +++ b/src/libANGLE/State.h @@ -93,6 +93,7 @@ class State : angle::NonCopyable State(const State *shareContextState, egl::ShareGroup *shareGroup, TextureManager *shareTextures, + SemaphoreManager *shareSemaphores, const OverlayType *overlay, const EGLenum clientType, const Version &clientVersion, diff --git a/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp b/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp index 9894787c1..4355d9638 100644 --- a/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp +++ b/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp @@ -1298,8 +1298,9 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions outExtensions->flexibleSurfaceCompatibility = true; outExtensions->directComposition = !!mDCompModule; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; // syncControlCHROMIUM requires direct composition. outExtensions->syncControlCHROMIUM = outExtensions->directComposition; diff --git a/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp b/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp index 60629deec..e0d7f6128 100644 --- a/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp +++ b/src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp @@ -591,8 +591,9 @@ void Renderer9::generateDisplayExtensions(egl::DisplayExtensions *outExtensions) outExtensions->flexibleSurfaceCompatibility = true; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; // D3D9 can be used without an output surface outExtensions->surfacelessContext = true; diff --git a/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm b/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm index 19bb894b4..53fb0e514 100644 --- a/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm +++ b/src/libANGLE/renderer/gl/cgl/DisplayCGL.mm @@ -435,8 +435,9 @@ void DisplayCGL::generateExtensions(egl::DisplayExtensions *outExtensions) const outExtensions->surfacelessContext = true; outExtensions->deviceQuery = true; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; if (mSupportsGPUSwitching) { diff --git a/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm b/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm index 29e83871c..d2d6cbecc 100644 --- a/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm +++ b/src/libANGLE/renderer/gl/eagl/DisplayEAGL.mm @@ -279,8 +279,9 @@ void DisplayEAGL::generateExtensions(egl::DisplayExtensions *outExtensions) cons outExtensions->surfacelessContext = true; outExtensions->deviceQuery = true; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures ans semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; outExtensions->powerPreference = false; diff --git a/src/libANGLE/renderer/gl/egl/DisplayEGL.cpp b/src/libANGLE/renderer/gl/egl/DisplayEGL.cpp index e6757759b..a5b10a180 100644 --- a/src/libANGLE/renderer/gl/egl/DisplayEGL.cpp +++ b/src/libANGLE/renderer/gl/egl/DisplayEGL.cpp @@ -616,8 +616,9 @@ void DisplayEGL::generateExtensions(egl::DisplayExtensions *outExtensions) const outExtensions->postSubBuffer = false; // Since SurfaceEGL::postSubBuffer is not implemented outExtensions->presentationTime = mEGL->hasExtension("EGL_ANDROID_presentation_time"); - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; // We will fallback to regular swap if swapBuffersWithDamage isn't // supported, so indicate support here to keep validation happy. diff --git a/src/libANGLE/renderer/gl/glx/DisplayGLX.cpp b/src/libANGLE/renderer/gl/glx/DisplayGLX.cpp index 34e688a8b..acc122e9b 100644 --- a/src/libANGLE/renderer/gl/glx/DisplayGLX.cpp +++ b/src/libANGLE/renderer/gl/glx/DisplayGLX.cpp @@ -880,8 +880,9 @@ void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const { outExtensions->createContextRobustness = mHasARBCreateContextRobustness; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures ans semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; outExtensions->surfacelessContext = true; diff --git a/src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp b/src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp index 7f79db7d9..61f3cf0c9 100644 --- a/src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp +++ b/src/libANGLE/renderer/gl/wgl/DisplayWGL.cpp @@ -645,8 +645,9 @@ void DisplayWGL::generateExtensions(egl::DisplayExtensions *outExtensions) const outExtensions->querySurfacePointer = true; outExtensions->keyedMutex = true; - // Contexts are virtualized so textures can be shared globally - outExtensions->displayTextureShareGroup = true; + // Contexts are virtualized so textures and semaphores can be shared globally + outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; outExtensions->surfacelessContext = true; diff --git a/src/libANGLE/renderer/vulkan/DisplayVk.cpp b/src/libANGLE/renderer/vulkan/DisplayVk.cpp index 35860feae..e186538e9 100644 --- a/src/libANGLE/renderer/vulkan/DisplayVk.cpp +++ b/src/libANGLE/renderer/vulkan/DisplayVk.cpp @@ -195,6 +195,7 @@ void DisplayVk::generateExtensions(egl::DisplayExtensions *outExtensions) const outExtensions->createContextRobustness = getRenderer()->getNativeExtensions().robustness; outExtensions->surfaceOrientation = true; outExtensions->displayTextureShareGroup = true; + outExtensions->displaySemaphoreShareGroup = true; outExtensions->robustResourceInitialization = true; // The Vulkan implementation will always say that EGL_KHR_swap_buffers_with_damage is supported. diff --git a/src/libANGLE/validationEGL.cpp b/src/libANGLE/validationEGL.cpp index b566cf0fd..89c1fe5da 100644 --- a/src/libANGLE/validationEGL.cpp +++ b/src/libANGLE/validationEGL.cpp @@ -1278,6 +1278,27 @@ Error ValidateCreateContext(Display *display, } break; + case EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE: + if (!display->getExtensions().displayTextureShareGroup) + { + return EglBadAttribute() << "Attribute " + "EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE requires " + "EGL_ANGLE_display_semaphore_share_group."; + } + if (value != EGL_TRUE && value != EGL_FALSE) + { + return EglBadAttribute() << "EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE must be " + "EGL_TRUE or EGL_FALSE."; + } + if (shareContext && + (shareContext->usingDisplaySemaphoreShareGroup() != (value == EGL_TRUE))) + { + return EglBadAttribute() << "All contexts within a share group must be " + "created with the same value of " + "EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE."; + } + break; + case EGL_CONTEXT_CLIENT_ARRAYS_ENABLED_ANGLE: if (!display->getExtensions().createContextClientArrays) {