kc3-lang/angle/src/libGLESv2/global_state.h

• Show log

  Commit

• Hash : 33c28e35
  Author :
  Date : 2020-06-12T08:17:47
  

  Optimize thread specific storage and retrieval with native ASM
  
  Android reserves specific TLS slots to store thread specific
  values. Given that the Context object gets queried on every
  call we leverage Android's ASM code to improve the speed of
  this operation.
  
  TLS_SLOT_OPENGL is an unused slot in Android and using that
  in combination with the ASM code,rather than using the
  pthread API, allows angle to store and retrieve thread specific
  context object much more efficiently.
  
  Bug: angleproject:4717
  Change-Id: I27a117fe82e62407e01c8c372918b866aaea9ee5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2231883
  Commit-Queue: Mohan Maiya <m.maiya@samsung.com>
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libGLESv2/global_state.h

• //
  // 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.
  //
  
  // global_state.h : Defines functions for querying the thread-local GL and EGL state.
  
  #ifndef LIBGLESV2_GLOBALSTATE_H_
  #define LIBGLESV2_GLOBALSTATE_H_
  
  #include "common/tls.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Thread.h"
  #include "libANGLE/features.h"
  
  #include <mutex>
  
  namespace angle
  {
  using GlobalMutex = std::recursive_mutex;
  }  // namespace angle
  
  namespace egl
  {
  class Debug;
  class Thread;
  
  angle::GlobalMutex &GetGlobalMutex();
  Thread *GetCurrentThread();
  Debug *GetDebug();
  void SetContextCurrent(Thread *thread, gl::Context *context);
  }  // namespace egl
  
  #define ANGLE_SCOPED_GLOBAL_LOCK() \
      std::lock_guard<angle::GlobalMutex> globalMutexLock(egl::GetGlobalMutex())
  
  namespace gl
  {
  extern Context *gSingleThreadedContext;
  
  ANGLE_INLINE Context *GetGlobalContext()
  {
      if (gSingleThreadedContext)
      {
          return gSingleThreadedContext;
      }
      else
      {
          Context *context;
          bool fastTlsResult = GetContextFromAndroidOpenGLTLSSlot(&context);
          if (fastTlsResult)
          {
              return context;
          }
      }
  
      egl::Thread *thread = egl::GetCurrentThread();
      return thread->getContext();
  }
  
  ANGLE_INLINE Context *GetValidGlobalContext()
  {
      if (gSingleThreadedContext && !gSingleThreadedContext->isContextLost())
      {
          return gSingleThreadedContext;
      }
      else if (!gSingleThreadedContext)
      {
          Context *context;
          bool fastTlsResult = GetContextFromAndroidOpenGLTLSSlot(&context);
          if (fastTlsResult)
          {
              if (context && !context->isContextLost())
              {
                  return context;
              }
          }
      }
  
      egl::Thread *thread = egl::GetCurrentThread();
      return thread->getValidContext();
  }
  
  ANGLE_INLINE std::unique_lock<angle::GlobalMutex> GetShareGroupLock(const Context *context)
  {
      return context->isShared() ? std::unique_lock<angle::GlobalMutex>(egl::GetGlobalMutex())
                                 : std::unique_lock<angle::GlobalMutex>();
  }
  }  // namespace gl
  
  #endif  // LIBGLESV2_GLOBALSTATE_H_
  

Download