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

• Show log

  Commit

• Hash : f1345d1c
  Author :
  Date : 2023-08-02T14:23:59
  

  Call ReleaseThread() entry point from ThreadCleanupCallback
  
  Change relevant only for the Android platform.
  
  Fixes problems:
  1. Current code calls `thread->setCurrent(nullptr)` in
     `Display::threadCleanup()` method, while not executing other code
     that will actually unmake Context from current. This will affect
     following EGL calls from the application's side in its own thread
     cleanup callback. For example, calls to `eglMakeCurrent()` (to unmake
     from current) or `eglReleaseThread()` will be no-op. This may lead to
     memory leak if context was previously marked for destruction.
  
  2. The `Display::threadCleanup()` did not also clears
     the `CurrentValidContext`. This may cause crashes or other UB if an
     application will call some GLES API in its thread termination
     callback (for example `glFinish()`), if ANGLE already destroyed the
     context in its ThreadCleanupCallback (use after delete).
  
  3. Context will remain current to a thread that terminated. Current
     implementation of GLES drivers on Mali/Adreno GPUs automatically
     unmade context from current, so the application may make this context
     current to some other thread. ANGLE should mimic this behavior to
     avoid possible bugs.
  
  All of the above problems may be fixed by simply calling from the
  ThreadCleanupCallback either:
  - MakeCurrent(t, d, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)
  - ReleaseThread(t)
  
  This CL choose to call `ReleaseThread()` because this is the API that
  the application may call in its own thread cleanup callback. And if
  application's callback will be called later than ANGLE's callback, then
  application's `eglReleaseThread()` call we be a no-op.
  
  Even if the application does not have its own thread cleanup callback
  (like most of the applications), there is no harm to call
  `ReleaseThread()` anyway. The only difference with `MakeCurrent()` is
  that it will also cleanup invalid objects and some other memory
  depending on the backend.
  
  This CL naturally replaces existing logic with Display termination when
  there is no active threads thanks to the previous CL:
      "Perform Display terminate(InternalCleanup) from makeCurrent()".
  
  Bug: angleproject:6723
  Bug: angleproject:8283
  Test: angle_end2end_tests --gtest_filter=EGLContextSharingTest.ThreadCleanupCallback*
  Test: angle_end2end_tests --gtest_filter=EGLContextSharingTest.UnmakeFromCurrentOnThreadExit*
  Change-Id: I8c5b31f34f91c4bfdac165ac30c213ff5fef992e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4742383
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
  

Download

• src/libANGLE/Thread.h

• //
  // Copyright 2016 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.
  //
  
  // Thread.h : Defines the Thread class which represents a global EGL thread.
  
  #ifndef LIBANGLE_THREAD_H_
  #define LIBANGLE_THREAD_H_
  
  #include <EGL/egl.h>
  
  #include "libANGLE/Debug.h"
  
  #include <atomic>
  
  namespace angle
  {
  #if defined(ANGLE_USE_ANDROID_TLS_SLOT)
  extern bool gUseAndroidOpenGLTlsSlot;
  #endif
  }  // namespace angle
  
  namespace gl
  {
  class Context;
  }  // namespace gl
  
  namespace egl
  {
  class Error;
  class Debug;
  class Display;
  class Surface;
  
  class Thread : public LabeledObject
  {
    public:
      Thread();
  
      void setLabel(EGLLabelKHR label) override;
      EGLLabelKHR getLabel() const override;
  
      void setSuccess();
  
      void setError(EGLint error,
                    const char *command,
                    const LabeledObject *object,
                    const char *message);
  
      // TODO: Remove egl::Error. http://anglebug.com/3041
      void setError(const Error &error, const char *command, const LabeledObject *object);
      EGLint getError() const;
  
      void setAPI(EGLenum api);
      EGLenum getAPI() const;
  
      void setCurrent(gl::Context *context);
      Surface *getCurrentDrawSurface() const;
      Surface *getCurrentReadSurface() const;
      gl::Context *getContext() const;
      Display *getDisplay() const;
  
    private:
      EGLLabelKHR mLabel;
      EGLint mError;
      EGLenum mAPI;
      gl::Context *mContext;
  };
  
  void EnsureDebugAllocated();
  void DeallocateDebug();
  Debug *GetDebug();
  
  }  // namespace egl
  
  #endif  // LIBANGLE_THREAD_H_
  

Download