kc3-lang/angle/src/libANGLE/renderer/DisplayImpl.cpp

• Show log

  Commit

• Hash : 9637185c
  Author :
  Date : 2022-03-10T15:38:13
  

  Add ForceGPUSwitch to EGL_ANGLE_power_preference
  
  eglHandleGPUSwitch() does not work with WebKit sandbox profile.
  The root cause is that we do not know the
  primary display, and as such we do not know which GPU drives this.
  
  Add eglForceGPUSwitchANGLE(display, gpuIDHigh, gpuIDLow).
  This lets the caller figure out the GPU in another process. Then
  the caller can just set the GPU in the sandboxed process.
  
  Add tests that are disabled by default until the runner and the
  infrastructure supports running the tests with automatic switching
  enabled.
  
  Bug: angleproject:7092
  Change-Id: I316ee431156596effbdb89659a5e24291719a204
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3516274
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  Commit-Queue: Kenneth Russell <kbr@chromium.org>
  

Download

• src/libANGLE/renderer/DisplayImpl.cpp

• //
  // Copyright 2014 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.
  //
  
  // DisplayImpl.cpp: Implementation methods of egl::Display
  
  #include "libANGLE/renderer/DisplayImpl.h"
  
  #include "libANGLE/Display.h"
  #include "libANGLE/Surface.h"
  #include "libANGLE/renderer/DeviceImpl.h"
  
  namespace rx
  {
  namespace
  {
  // For back-ends that do not implement EGLDevice.
  class MockDevice : public DeviceImpl
  {
    public:
      MockDevice() = default;
      egl::Error initialize() override { return egl::NoError(); }
      egl::Error getAttribute(const egl::Display *display, EGLint attribute, void **outValue) override
      {
          UNREACHABLE();
          return egl::EglBadAttribute();
      }
      EGLint getType() override
      {
          UNREACHABLE();
          return EGL_NONE;
      }
      void generateExtensions(egl::DeviceExtensions *outExtensions) const override
      {
          *outExtensions = egl::DeviceExtensions();
      }
  };
  }  // anonymous namespace
  
  DisplayImpl::DisplayImpl(const egl::DisplayState &state)
      : mState(state), mExtensionsInitialized(false), mCapsInitialized(false), mBlobCache(nullptr)
  {}
  
  DisplayImpl::~DisplayImpl()
  {
      ASSERT(mState.surfaceSet.empty());
  }
  
  egl::Error DisplayImpl::prepareForCall()
  {
      return egl::NoError();
  }
  
  egl::Error DisplayImpl::releaseThread()
  {
      return egl::NoError();
  }
  
  const egl::DisplayExtensions &DisplayImpl::getExtensions() const
  {
      if (!mExtensionsInitialized)
      {
          generateExtensions(&mExtensions);
          mExtensionsInitialized = true;
      }
  
      return mExtensions;
  }
  
  egl::Error DisplayImpl::handleGPUSwitch()
  {
      return egl::NoError();
  }
  
  egl::Error DisplayImpl::forceGPUSwitch(EGLint gpuIDHigh, EGLint gpuIDLow)
  {
      return egl::NoError();
  }
  
  egl::Error DisplayImpl::validateClientBuffer(const egl::Config *configuration,
                                               EGLenum buftype,
                                               EGLClientBuffer clientBuffer,
                                               const egl::AttributeMap &attribs) const
  {
      UNREACHABLE();
      return egl::EglBadDisplay() << "DisplayImpl::validateClientBuffer unimplemented.";
  }
  
  egl::Error DisplayImpl::validateImageClientBuffer(const gl::Context *context,
                                                    EGLenum target,
                                                    EGLClientBuffer clientBuffer,
                                                    const egl::AttributeMap &attribs) const
  {
      UNREACHABLE();
      return egl::EglBadDisplay() << "DisplayImpl::validateImageClientBuffer unimplemented.";
  }
  
  egl::Error DisplayImpl::validatePixmap(const egl::Config *config,
                                         EGLNativePixmapType pixmap,
                                         const egl::AttributeMap &attributes) const
  {
      UNREACHABLE();
      return egl::EglBadDisplay() << "DisplayImpl::valdiatePixmap unimplemented.";
  }
  
  const egl::Caps &DisplayImpl::getCaps() const
  {
      if (!mCapsInitialized)
      {
          generateCaps(&mCaps);
          mCapsInitialized = true;
      }
  
      return mCaps;
  }
  
  DeviceImpl *DisplayImpl::createDevice()
  {
      return new MockDevice();
  }
  
  bool DisplayImpl::isX11() const
  {
      return false;
  }
  
  bool DisplayImpl::supportsDmaBufFormat(EGLint format) const
  {
      UNREACHABLE();
      return false;
  }
  
  egl::Error DisplayImpl::queryDmaBufFormats(EGLint max_formats, EGLint *formats, EGLint *num_formats)
  {
      UNREACHABLE();
      return egl::NoError();
  }
  
  egl::Error DisplayImpl::queryDmaBufModifiers(EGLint format,
                                               EGLint max_modifiers,
                                               EGLuint64KHR *modifiers,
                                               EGLBoolean *external_only,
                                               EGLint *num_modifiers)
  {
      UNREACHABLE();
      return egl::NoError();
  }
  
  }  // namespace rx
  

Download