kc3-lang/angle/src/libANGLE/Display.h

• Show log

  Commit

• Hash : 36c3e0f5
  Author :
  Date : 2023-01-17T17:42:59
  

  Implement "Shared Context Mutex" functionality.
  
  Existing implementation uses single `GlobalMutex` for
  - EGL calls
  - GL calls for Contexts with concurrent access.
  
  This CL introduces abstract `egl::ContextMutex` with two
  implementations:
  - SingleContextMutex;
  - SharedContextMutex<Mutex>;
  
  Note:
  `std::mutex` is used in this commit. It is very easy to change mutex
  type either at compile-time or at run-time (single type per Display).
  
  When Context:
  - is not Shared;
  - does not use `EGLImage`s;
  - does not use EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE
  - does not use EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE
  then it will be using `SingleContextMutex` with minimal overhead.
  
  Before such Context is used as `shareContext` or uses `EGLImage`
  its mutex replaced by `SharedContextMutex<Mutex>`.
  
  The `GlobalMutex` is only used for EGL calls, while `egl::ContextMutex`
  implementations for GL calls. Because some EGL calls use Context,
  explicit `egl::ContextMutex` lock is required. This is implemented by
  generating "egl_context_mutex_autogen.h" header, and insertion of
  `ANGLE_EGL_SCOPED_CONTEXT_LOCK()` macro before `ANGLE_EGL_VALIDATE()`
  in each EGL entry point. Implementation in "egl_context_lock_impl.h"
  returns lock for required APIs. Special cases of `egl::ContextMutex`
  lock handled separately. `std::unique_lock<>` is not used for
  performance reasons.
  
  `egl::ContextMutex` explicitly locked when capturing EGL calls.
  
  Fixes EGLImage problem:
      https://chromium.googlesource.com/angle/angle/+/e18240d136d15e5cdfa4fa4a6355ca21c8d807b6
      Mark contexts as shared when importing EGL images.
  
  Details:
  - EGLImage inherits Context's mutex when created.
    Mutex is used when the EGLImage accessed or destroyed.
  - When EGLImage is used in Context with other `egl::ContextMutex`,
    two mutexes are merged into one.
  - After the mutex merge, Context Groups will remain separate,
    but will not be able to run in parallel.
  
  Fixes race when checking `context->isShared()` in the
  `SCOPED_SHARE_CONTEXT_LOCK()` macro. One Context may start executing GL
  call while not "Shared", but become "Shared" inside the call. New
  (second) "Shared" Context may immediately start using GL and potentially
  corrupt some "Shared" state.
  
  Possible performance benefit: allows parallel execution in some cases,
  when single `GlobalMutex` would block.
  
  Important note:
      Process of replacing the `SingleContextMutex` by
      `SharedContextMutex<Mutex>` is not 100% safe. This mean that
      original Context may still be using `SingleContextMutex` after
      activating `SharedContextMutex<Mutex>`. However, this was always
      the case before introduction of this CL. Old `Context::mShared`
      member update was not synchronized in any way at all. In other
      words, this solution does not 100% fix the original problem.
      For 100% safe solution `SingleContextMutex` should not be used
      (always pass `SharedContextMutex<Mutex>` to the `gl::Context`
      constructor). See `lockAndActivateSharedContextMutex()` for more
      details.
  
  CL adds new build option:
      angle_enable_shared_context_mutex = true
  
  Behavior with other build options:
  - When:
      `angle_enable_shared_context_mutex`    is disabled or
      `angle_enable_share_context_lock`      is disabled or
      `angle_force_context_check_every_call` is enabled,
    Contexts will always have `SingleContextMutex`, however it will be
    only used in special cases. `SCOPED_SHARE_CONTEXT_LOCK()` will use
    `GlobalMutex` when applicable.
  - Otherwise, `SCOPED_SHARE_CONTEXT_LOCK()` will use `egl::ContextMutex`.
  
  Some GFXBench "1080p Driver Overhead 2 Offscreen" performance numbers.
  Tested on S906B (Samsung Galaxy S22+) on old ANGLE base:
      https://chromium.googlesource.com/angle/angle/+/807c94ea85e046c6f279d081d99f0fb1bcf1191a
      Capture/Replay: Adjust tests do adhere to capture limits
  
  Each test result is an average frame number from 6 runs.
  
      SingleContextMutex                            6579 ( +0.13%)
      (old) GetContextLock() (mShared is false)     6570
  
  Forced `mShared = true` or NOT using `SingleContextMutex`.
  
      SharedContextMutex<std::mutex> FORCE          5061 (-22.97%)
      (old) GetContextLock() FORCE                  4766 (-27.46%)
  
  Bug: angleproject:6957
  Bug: chromium:1336126
  Change-Id: Idcd919f9d4bf482b9ae489bd8b4415ec96048e32
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4374545
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/Display.h

• //
  // Copyright 2002 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // Display.h: Defines the egl::Display class, representing the abstract
  // display on which graphics are drawn. Implements EGLDisplay.
  // [EGL 1.4] section 2.1.2 page 3.
  
  #ifndef LIBANGLE_DISPLAY_H_
  #define LIBANGLE_DISPLAY_H_
  
  #include <mutex>
  #include <vector>
  
  #include "common/WorkerThread.h"
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/BlobCache.h"
  #include "libANGLE/Caps.h"
  #include "libANGLE/Config.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/LoggingAnnotator.h"
  #include "libANGLE/MemoryProgramCache.h"
  #include "libANGLE/MemoryShaderCache.h"
  #include "libANGLE/Observer.h"
  #include "libANGLE/Version.h"
  #include "platform/Feature.h"
  #include "platform/autogen/FrontendFeatures_autogen.h"
  
  namespace angle
  {
  class FrameCaptureShared;
  }  // namespace angle
  
  namespace gl
  {
  class Context;
  class TextureManager;
  class SemaphoreManager;
  }  // namespace gl
  
  namespace rx
  {
  class DisplayImpl;
  class EGLImplFactory;
  class ShareGroupImpl;
  }  // namespace rx
  
  namespace egl
  {
  class Device;
  class Image;
  class Stream;
  class Surface;
  class Sync;
  class Thread;
  
  using ContextMap = angle::HashMap<GLuint, gl::Context *>;
  using SurfaceMap = angle::HashMap<GLuint, Surface *>;
  using ThreadSet  = angle::HashSet<Thread *>;
  
  struct DisplayState final : private angle::NonCopyable
  {
      DisplayState(EGLNativeDisplayType nativeDisplayId);
      ~DisplayState();
  
      EGLLabelKHR label;
      ContextMap contextMap;
      SurfaceMap surfaceMap;
      std::vector<std::string> featureOverridesEnabled;
      std::vector<std::string> featureOverridesDisabled;
      bool featuresAllDisabled;
      EGLNativeDisplayType displayId;
  };
  
  class ShareGroup final : angle::NonCopyable
  {
    public:
      ShareGroup(rx::EGLImplFactory *factory);
  
      void addRef();
  
      void release(const egl::Display *display);
  
      rx::ShareGroupImpl *getImplementation() const { return mImplementation; }
  
      rx::UniqueSerial generateFramebufferSerial() { return mFramebufferSerialFactory.generate(); }
  
      angle::FrameCaptureShared *getFrameCaptureShared() { return mFrameCaptureShared.get(); }
  
      void finishAllContexts();
  
      const ContextMap &getContexts() const { return mContexts; }
      void addSharedContext(gl::Context *context);
      void removeSharedContext(gl::Context *context);
  
      size_t getShareGroupContextCount() const { return mContexts.size(); }
  
    protected:
      ~ShareGroup();
  
    private:
      size_t mRefCount;
      rx::ShareGroupImpl *mImplementation;
      rx::UniqueSerialFactory mFramebufferSerialFactory;
  
      // Note: we use a raw pointer here so we can exclude frame capture sources from the build.
      std::unique_ptr<angle::FrameCaptureShared> mFrameCaptureShared;
  
      // The list of contexts within the share group
      ContextMap mContexts;
  };
  
  // Constant coded here as a reasonable limit.
  constexpr EGLAttrib kProgramCacheSizeAbsoluteMax = 0x4000000;
  
  using ImageMap  = angle::HashMap<GLuint, Image *>;
  using StreamSet = angle::HashSet<Stream *>;
  using SyncMap   = angle::HashMap<GLuint, Sync *>;
  
  class Display final : public LabeledObject,
                        public angle::ObserverInterface,
                        public angle::NonCopyable
  {
    public:
      ~Display() override;
  
      void setLabel(EGLLabelKHR label) override;
      EGLLabelKHR getLabel() const override;
  
      // Observer implementation.
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
      Error initialize();
  
      enum class TerminateReason
      {
          Api,
          InternalCleanup,
          NoActiveThreads,
  
          InvalidEnum,
          EnumCount = InvalidEnum,
      };
      Error terminate(Thread *thread, TerminateReason terminateReason);
      // Called before all display state dependent EGL functions. Backends can set up, for example,
      // thread-specific backend state through this function. Not called for functions that do not
      // need the state.
      Error prepareForCall();
      // Called on eglReleaseThread. Backends can tear down thread-specific backend state through
      // this function.
      Error releaseThread();
  
      // Helpers to maintain active thread set to assist with freeing invalid EGL objects.
      void addActiveThread(Thread *thread);
      void threadCleanup(Thread *thread);
  
      ContextMutexManager *getSharedContextMutexManager() const
      {
          return mSharedContextMutexManager.get();
      }
  
      static Display *GetDisplayFromDevice(Device *device, const AttributeMap &attribMap);
      static Display *GetDisplayFromNativeDisplay(EGLenum platform,
                                                  EGLNativeDisplayType nativeDisplay,
                                                  const AttributeMap &attribMap);
      static Display *GetExistingDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay);
  
      using EglDisplaySet = angle::HashSet<Display *>;
      static EglDisplaySet GetEglDisplaySet();
  
      static const ClientExtensions &GetClientExtensions();
      static const std::string &GetClientExtensionString();
  
      std::vector<const Config *> getConfigs(const AttributeMap &attribs) const;
      std::vector<const Config *> chooseConfig(const AttributeMap &attribs) const;
  
      Error createWindowSurface(const Config *configuration,
                                EGLNativeWindowType window,
                                const AttributeMap &attribs,
                                Surface **outSurface);
      Error createPbufferSurface(const Config *configuration,
                                 const AttributeMap &attribs,
                                 Surface **outSurface);
      Error createPbufferFromClientBuffer(const Config *configuration,
                                          EGLenum buftype,
                                          EGLClientBuffer clientBuffer,
                                          const AttributeMap &attribs,
                                          Surface **outSurface);
      Error createPixmapSurface(const Config *configuration,
                                NativePixmapType nativePixmap,
                                const AttributeMap &attribs,
                                Surface **outSurface);
  
      Error createImage(const gl::Context *context,
                        EGLenum target,
                        EGLClientBuffer buffer,
                        const AttributeMap &attribs,
                        Image **outImage);
  
      Error createStream(const AttributeMap &attribs, Stream **outStream);
  
      Error createContext(const Config *configuration,
                          gl::Context *shareContext,
                          const EGLenum clientType,
                          const AttributeMap &attribs,
                          gl::Context **outContext);
  
      Error createSync(const gl::Context *currentContext,
                       EGLenum type,
                       const AttributeMap &attribs,
                       Sync **outSync);
  
      Error makeCurrent(Thread *thread,
                        gl::Context *previousContext,
                        Surface *drawSurface,
                        Surface *readSurface,
                        gl::Context *context);
  
      Error destroySurface(Surface *surface);
      void destroyImage(Image *image);
      void destroyStream(Stream *stream);
      Error destroyContext(Thread *thread, gl::Context *context);
  
      void destroySync(Sync *sync);
  
      bool isInitialized() const;
      bool isValidConfig(const Config *config) const;
      bool isValidContext(gl::ContextID contextID) const;
      bool isValidSurface(SurfaceID surfaceID) const;
      bool isValidImage(ImageID imageID) const;
      bool isValidStream(const Stream *stream) const;
      bool isValidSync(SyncID sync) const;
      bool isValidNativeWindow(EGLNativeWindowType window) const;
  
      Error validateClientBuffer(const Config *configuration,
                                 EGLenum buftype,
                                 EGLClientBuffer clientBuffer,
                                 const AttributeMap &attribs) const;
      Error validateImageClientBuffer(const gl::Context *context,
                                      EGLenum target,
                                      EGLClientBuffer clientBuffer,
                                      const egl::AttributeMap &attribs) const;
      Error valdiatePixmap(const Config *config,
                           EGLNativePixmapType pixmap,
                           const AttributeMap &attributes) const;
  
      static bool isValidDisplay(const Display *display);
      static bool isValidNativeDisplay(EGLNativeDisplayType display);
      static bool hasExistingWindowSurface(EGLNativeWindowType window);
  
      bool isDeviceLost() const;
      bool testDeviceLost();
      void notifyDeviceLost();
  
      void setBlobCacheFuncs(EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
      bool areBlobCacheFuncsSet() const { return mBlobCache.areBlobCacheFuncsSet(); }
      BlobCache &getBlobCache() { return mBlobCache; }
  
      static EGLClientBuffer GetNativeClientBuffer(const struct AHardwareBuffer *buffer);
      static Error CreateNativeClientBuffer(const egl::AttributeMap &attribMap,
                                            EGLClientBuffer *eglClientBuffer);
  
      Error waitClient(const gl::Context *context);
      Error waitNative(const gl::Context *context, EGLint engine);
  
      const Caps &getCaps() const;
  
      const DisplayExtensions &getExtensions() const;
      const std::string &getExtensionString() const;
      const std::string &getVendorString() const;
      const std::string &getVersionString() const;
      const std::string &getClientAPIString() const;
  
      std::string getBackendRendererDescription() const;
      std::string getBackendVendorString() const;
      std::string getBackendVersionString(bool includeFullVersion) const;
  
      EGLint programCacheGetAttrib(EGLenum attrib) const;
      Error programCacheQuery(EGLint index,
                              void *key,
                              EGLint *keysize,
                              void *binary,
                              EGLint *binarysize);
      Error programCachePopulate(const void *key,
                                 EGLint keysize,
                                 const void *binary,
                                 EGLint binarysize);
      EGLint programCacheResize(EGLint limit, EGLenum mode);
  
      const AttributeMap &getAttributeMap() const { return mAttributeMap; }
      EGLNativeDisplayType getNativeDisplayId() const { return mState.displayId; }
  
      rx::DisplayImpl *getImplementation() const { return mImplementation; }
      Device *getDevice() const;
      Surface *getWGLSurface() const;
      EGLenum getPlatform() const { return mPlatform; }
  
      gl::Version getMaxSupportedESVersion() const;
  
      const DisplayState &getState() const { return mState; }
  
      const angle::FrontendFeatures &getFrontendFeatures() { return mFrontendFeatures; }
      void overrideFrontendFeatures(const std::vector<std::string> &featureNames, bool enabled);
  
      const angle::FeatureList &getFeatures() const { return mFeatures; }
  
      const char *queryStringi(const EGLint name, const EGLint index);
  
      EGLAttrib queryAttrib(const EGLint attribute);
  
      angle::ScratchBuffer requestScratchBuffer();
      void returnScratchBuffer(angle::ScratchBuffer scratchBuffer);
  
      angle::ScratchBuffer requestZeroFilledBuffer();
      void returnZeroFilledBuffer(angle::ScratchBuffer zeroFilledBuffer);
  
      egl::Error handleGPUSwitch();
      egl::Error forceGPUSwitch(EGLint gpuIDHigh, EGLint gpuIDLow);
  
      egl::Error waitUntilWorkScheduled();
  
      std::mutex &getDisplayGlobalMutex() { return mDisplayGlobalMutex; }
      std::mutex &getProgramCacheMutex() { return mProgramCacheMutex; }
  
      gl::MemoryShaderCache *getMemoryShaderCache() { return &mMemoryShaderCache; }
  
      // Installs LoggingAnnotator as the global DebugAnnotator, for back-ends that do not implement
      // their own DebugAnnotator.
      void setGlobalDebugAnnotator() { gl::InitializeDebugAnnotations(&mAnnotator); }
  
      bool supportsDmaBufFormat(EGLint format) const;
      Error queryDmaBufFormats(EGLint max_formats, EGLint *formats, EGLint *num_formats);
      Error queryDmaBufModifiers(EGLint format,
                                 EGLint max_modifiers,
                                 EGLuint64KHR *modifiers,
                                 EGLBoolean *external_only,
                                 EGLint *num_modifiers);
  
      std::shared_ptr<angle::WorkerThreadPool> getSingleThreadPool() const
      {
          return mSingleThreadPool;
      }
      std::shared_ptr<angle::WorkerThreadPool> getMultiThreadPool() const { return mMultiThreadPool; }
  
      angle::ImageLoadContext getImageLoadContext() const;
  
      const gl::Context *getContext(gl::ContextID contextID) const;
      const egl::Surface *getSurface(egl::SurfaceID surfaceID) const;
      const egl::Image *getImage(egl::ImageID imageID) const;
      const egl::Sync *getSync(egl::SyncID syncID) const;
      gl::Context *getContext(gl::ContextID contextID);
      egl::Surface *getSurface(egl::SurfaceID surfaceID);
      egl::Image *getImage(egl::ImageID imageID);
      egl::Sync *getSync(egl::SyncID syncID);
  
      const SyncMap &getSyncsForCapture() const { return mSyncMap; }
  
      // Initialize thread-local variables used by the Display and its backing implementations.  This
      // includes:
      //
      // - The unlocked tail call to be run at the end of the entry point.
      // - Scratch space for an egl::Error used by the backends (this is not used by all backends, and
      //   access *must* be restricted to backends that use it).
      //
      static void InitTLS();
      static angle::UnlockedTailCall *GetCurrentThreadUnlockedTailCall();
      static Error *GetCurrentThreadErrorScratchSpace();
  
    private:
      Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDevice);
  
      void setAttributes(const AttributeMap &attribMap) { mAttributeMap = attribMap; }
      void setupDisplayPlatform(rx::DisplayImpl *impl);
  
      Error restoreLostDevice();
      Error releaseContext(gl::Context *context, Thread *thread);
      Error releaseContextImpl(gl::Context *context, ContextMap *contexts);
  
      void initDisplayExtensions();
      void initVendorString();
      void initVersionString();
      void initClientAPIString();
      void initializeFrontendFeatures();
  
      angle::ScratchBuffer requestScratchBufferImpl(std::vector<angle::ScratchBuffer> *bufferVector);
      void returnScratchBufferImpl(angle::ScratchBuffer scratchBuffer,
                                   std::vector<angle::ScratchBuffer> *bufferVector);
  
      Error destroyInvalidEglObjects();
  
      DisplayState mState;
      rx::DisplayImpl *mImplementation;
      angle::ObserverBinding mGPUSwitchedBinding;
  
      AttributeMap mAttributeMap;
  
      ConfigSet mConfigSet;
  
      ImageMap mImageMap;
      StreamSet mStreamSet;
      SyncMap mSyncMap;
  
      void destroyImageImpl(Image *image, ImageMap *images);
      void destroyStreamImpl(Stream *stream, StreamSet *streams);
      Error destroySurfaceImpl(Surface *surface, SurfaceMap *surfaces);
      void destroySyncImpl(Sync *sync, SyncMap *syncs);
  
      ContextMap mInvalidContextMap;
      ImageMap mInvalidImageMap;
      StreamSet mInvalidStreamSet;
      SurfaceMap mInvalidSurfaceMap;
      SyncMap mInvalidSyncMap;
  
      bool mInitialized;
      bool mDeviceLost;
  
      Caps mCaps;
  
      DisplayExtensions mDisplayExtensions;
      std::string mDisplayExtensionString;
  
      std::string mVendorString;
      std::string mVersionString;
      std::string mClientAPIString;
  
      Device *mDevice;
      Surface *mSurface;
      EGLenum mPlatform;
      angle::LoggingAnnotator mAnnotator;
  
      std::unique_ptr<ContextMutexManager> mSharedContextMutexManager;
  
      // mManagersMutex protects mTextureManager and mSemaphoreManager
      ContextMutex *mManagersMutex;
      gl::TextureManager *mTextureManager;
      gl::SemaphoreManager *mSemaphoreManager;
  
      BlobCache mBlobCache;
      gl::MemoryProgramCache mMemoryProgramCache;
      gl::MemoryShaderCache mMemoryShaderCache;
      size_t mGlobalTextureShareGroupUsers;
      size_t mGlobalSemaphoreShareGroupUsers;
  
      gl::HandleAllocator mImageHandleAllocator;
      gl::HandleAllocator mSurfaceHandleAllocator;
      gl::HandleAllocator mSyncHandleAllocator;
  
      angle::FrontendFeatures mFrontendFeatures;
  
      angle::FeatureList mFeatures;
  
      std::mutex mScratchBufferMutex;
      std::vector<angle::ScratchBuffer> mScratchBuffers;
      std::vector<angle::ScratchBuffer> mZeroFilledBuffers;
  
      std::mutex mDisplayGlobalMutex;
      std::mutex mProgramCacheMutex;
  
      bool mTerminatedByApi;
      ThreadSet mActiveThreads;
  
      // Single-threaded and multithread pools for use by various parts of ANGLE, such as shader
      // compilation.  These pools are internally synchronized.
      std::shared_ptr<angle::WorkerThreadPool> mSingleThreadPool;
      std::shared_ptr<angle::WorkerThreadPool> mMultiThreadPool;
  };
  
  }  // namespace egl
  
  #endif  // LIBANGLE_DISPLAY_H_
  

Download