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

• Show log

  Commit

• Hash : 6cced91b
  Author :
  Date : 2022-02-08T10:24:11
  

  FrameCapture: Remove destroyed contexts from share group
  
  If a GL Context is destroyed, remove it from the list of shared
  contexts tracked by FrameCapture.
  
  Before this CL, we would crash in runMidExecutionCapture when trying
  to iterate through contexts that were gone:
  
      INFO: checking for SetupCalls in context id: 1
      INFO: checking for SetupCalls in context id: 2
      INFO: checking for SetupCalls in context id: 1769237601
  
  Test: Mortal Kombat MEC
  Bug: angleproject:6997
  Change-Id: I3c2f6a77419d241af9a0b300936e7784446306f8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3448681
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  

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 <set>
  #include <vector>
  
  #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/Observer.h"
  #include "libANGLE/Version.h"
  #include "platform/Feature.h"
  #include "platform/FrontendFeatures.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 SurfaceSet = std::set<Surface *>;
  
  struct DisplayState final : private angle::NonCopyable
  {
      DisplayState(EGLNativeDisplayType nativeDisplayId);
      ~DisplayState();
  
      EGLLabelKHR label;
      SurfaceSet surfaceSet;
      std::vector<std::string> featureOverridesEnabled;
      std::vector<std::string> featureOverridesDisabled;
      bool featuresAllDisabled;
      EGLNativeDisplayType displayId;
  };
  
  using ContextSet = std::set<gl::Context *>;
  
  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::Serial generateFramebufferSerial() { return mFramebufferSerialFactory.generate(); }
  
      angle::FrameCaptureShared *getFrameCaptureShared() { return mFrameCaptureShared.get(); }
  
      void finishAllContexts();
  
      const ContextSet &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::SerialFactory 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
      ContextSet mContexts;
  };
  
  // Constant coded here as a reasonable limit.
  constexpr EGLAttrib kProgramCacheSizeAbsoluteMax = 0x4000000;
  
  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,
          ProcessExit,
  
          InvalidEnum,
          EnumCount = InvalidEnum,
      };
      Error terminate(Thread *thread, TerminateReason terminateReason);
      Error destroyInvalidEglObjects();
      // 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();
  
      static Display *GetDisplayFromDevice(Device *device, const AttributeMap &attribMap);
      static Display *GetDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay,
                                                  const AttributeMap &attribMap);
      static Display *GetExistingDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay);
  
      using EglDisplaySet = std::set<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(const gl::Context *context) const;
      bool isValidSurface(const Surface *surface) const;
      bool isValidImage(const Image *image) const;
      bool isValidStream(const Stream *stream) const;
      bool isValidSync(const Sync *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;
  
      std::string getBackendRendererDescription() const;
      std::string getBackendVendorString() const;
      std::string getBackendVersionString() 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();
  
      std::mutex &getDisplayGlobalMutex() { return mDisplayGlobalMutex; }
      std::mutex &getProgramCacheMutex() { return mProgramCacheMutex; }
  
      // Installs LoggingAnnotator as the global DebugAnnotator, for back-ends that do not implement
      // their own DebugAnnotator.
      void setGlobalDebugAnnotator() { gl::InitializeDebugAnnotations(&mAnnotator); }
  
    private:
      Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDevice);
  
      void setAttributes(const AttributeMap &attribMap) { mAttributeMap = attribMap; }
  
      void setupDisplayPlatform(rx::DisplayImpl *impl);
  
      void updateAttribsFromEnvironment(const AttributeMap &attribMap);
  
      Error restoreLostDevice();
      Error releaseContext(gl::Context *context, Thread *thread);
  
      void initDisplayExtensions();
      void initVendorString();
      void initVersionString();
      void initializeFrontendFeatures();
  
      angle::ScratchBuffer requestScratchBufferImpl(std::vector<angle::ScratchBuffer> *bufferVector);
      void returnScratchBufferImpl(angle::ScratchBuffer scratchBuffer,
                                   std::vector<angle::ScratchBuffer> *bufferVector);
  
      DisplayState mState;
      rx::DisplayImpl *mImplementation;
      angle::ObserverBinding mGPUSwitchedBinding;
  
      AttributeMap mAttributeMap;
  
      ConfigSet mConfigSet;
  
      ContextSet mContextSet;
  
      typedef std::set<Image *> ImageSet;
      ImageSet mImageSet;
  
      typedef std::set<Stream *> StreamSet;
      StreamSet mStreamSet;
  
      typedef std::set<Sync *> SyncSet;
      SyncSet mSyncSet;
  
      void destroyImageImpl(Image *image, ImageSet *images);
      void destroyStreamImpl(Stream *stream, StreamSet *streams);
      Error destroySurfaceImpl(Surface *surface, SurfaceSet *surfaces);
      void destroySyncImpl(Sync *sync, SyncSet *syncs);
  
      std::mutex mInvalidEglObjectsMutex;
      ImageSet mInvalidImageSet;
      StreamSet mInvalidStreamSet;
      SurfaceSet mInvalidSurfaceSet;
      SyncSet mInvalidSyncSet;
  
      bool mInitialized;
      bool mDeviceLost;
  
      Caps mCaps;
  
      DisplayExtensions mDisplayExtensions;
      std::string mDisplayExtensionString;
  
      std::string mVendorString;
      std::string mVersionString;
  
      Device *mDevice;
      Surface *mSurface;
      EGLenum mPlatform;
      angle::LoggingAnnotator mAnnotator;
  
      gl::TextureManager *mTextureManager;
      gl::SemaphoreManager *mSemaphoreManager;
      BlobCache mBlobCache;
      gl::MemoryProgramCache mMemoryProgramCache;
      size_t mGlobalTextureShareGroupUsers;
      size_t mGlobalSemaphoreShareGroupUsers;
  
      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 mIsTerminated;
  };
  
  }  // namespace egl
  
  #endif  // LIBANGLE_DISPLAY_H_
  

Download