improvements to CompilerThreadPool and OpenGLPlatform

filament/backend/include/backend/platforms/OpenGLPlatform.h

@@ -288,6 +288,12 @@ class OpenGLPlatform : public Platform {
      * @see terminate()
      */
     virtual void createContext(bool shared);
+
+    /**
+     * Detach and destroy the current context if any and releases all resources associated to
+     * this thread.
+     */
+    virtual void releaseContext() noexcept;
 };
 
 } // namespace filament

filament/backend/include/backend/platforms/PlatformEGL.h

@@ -40,6 +40,7 @@ class PlatformEGL : public OpenGLPlatform {
     PlatformEGL() noexcept;
     bool isExtraContextSupported() const noexcept override;
     void createContext(bool shared) override;
+    void releaseContext() noexcept override;
 
 protected:
 

filament/backend/src/CompilerThreadPool.cpp

@@ -34,17 +34,14 @@ CompilerThreadPool::~CompilerThreadPool() noexcept {
     assert_invariant(mQueues[1].empty());
 }
 
-void CompilerThreadPool::init(uint32_t threadCount, JobSystem::Priority priority,
-        ThreadSetup&& threadSetup) noexcept {
+void CompilerThreadPool::init(uint32_t threadCount,
+        ThreadSetup&& threadSetup, ThreadCleanup&& threadCleanup) noexcept {
     auto setup = std::make_shared<ThreadSetup>(std::move(threadSetup));
+    auto cleanup = std::make_shared<ThreadCleanup>(std::move(threadCleanup));
 
     for (size_t i = 0; i < threadCount; i++) {
-        mCompilerThreads.emplace_back([this, priority, setup]() {
+        mCompilerThreads.emplace_back([this, setup, cleanup]() {
             SYSTRACE_CONTEXT();
-            // give the thread a name
-            JobSystem::setThreadName("CompilerThreadPool");
-            // run at a slightly lower priority than other filament threads
-            JobSystem::setThreadPriority(priority);
 
             (*setup)();
 
@@ -80,6 +77,8 @@ void CompilerThreadPool::init(uint32_t threadCount, JobSystem::Priority priority
                     job();
                 }
             }
+
+            (*cleanup)();
         });
 
     }

filament/backend/src/CompilerThreadPool.h

@@ -20,12 +20,13 @@
 #include <backend/DriverEnums.h>
 
 #include <utils/Invocable.h>
-#include <utils/JobSystem.h>
+#include <utils/Mutex.h>
+#include <utils/Condition.h>
 
 #include <array>
-#include <atomic>
 #include <deque>
 #include <memory>
+#include <thread>
 #include <utility>
 #include <vector>
 
@@ -45,18 +46,19 @@ class CompilerThreadPool {
     ~CompilerThreadPool() noexcept;
     using Job = utils::Invocable<void()>;
     using ThreadSetup = utils::Invocable<void()>;
-    void init(uint32_t threadCount, utils::JobSystem::Priority priority,
-            ThreadSetup&& threadSetup) noexcept;
+    using ThreadCleanup = utils::Invocable<void()>;
+    void init(uint32_t threadCount,
+            ThreadSetup&& threadSetup, ThreadCleanup&& threadCleanup) noexcept;
     void terminate() noexcept;
     void queue(CompilerPriorityQueue priorityQueue, program_token_t const& token, Job&& job);
     Job dequeue(program_token_t const& token);
 
 private:
     using Queue = std::deque<std::pair<program_token_t, Job>>;
     std::vector<std::thread> mCompilerThreads;
-    std::atomic_bool mExitRequested{false};
-    std::mutex mQueueLock;
-    std::condition_variable mQueueCondition;
+    bool mExitRequested{ false };
+    utils::Mutex mQueueLock;
+    utils::Condition mQueueCondition;
     std::array<Queue, 2> mQueues;
     // lock must be held for methods below
     std::pair<Queue&, Queue::iterator> find(program_token_t const& token);

filament/backend/src/opengl/OpenGLPlatform.cpp

@@ -116,4 +116,7 @@ bool OpenGLPlatform::isExtraContextSupported() const noexcept {
 void OpenGLPlatform::createContext(bool) {
 }
 
+void OpenGLPlatform::releaseContext() noexcept {
+}
+
 } // namespace filament::backend

filament/backend/src/opengl/ShaderCompilerService.cpp

@@ -171,10 +171,18 @@ void ShaderCompilerService::init() noexcept {
             }
 
             mShaderCompilerThreadCount = poolSize;
-            mCompilerThreadPool.init(mShaderCompilerThreadCount, priority,
-                    [platform = &mDriver.mPlatform]() {
+            mCompilerThreadPool.init(mShaderCompilerThreadCount,
+                    [&platform = mDriver.mPlatform, priority]() {
+                        // give the thread a name
+                        JobSystem::setThreadName("CompilerThreadPool");
+                        // run at a slightly lower priority than other filament threads
+                        JobSystem::setThreadPriority(priority);
                         // create a gl context current to this thread
-                        platform->createContext(true);
+                        platform.createContext(true);
+                    },
+                    [&platform = mDriver.mPlatform]() {
+                        // release context and thread state
+                        platform.releaseContext();
                     });
         }
     }

filament/backend/src/opengl/platforms/PlatformEGL.cpp

@@ -294,6 +294,22 @@ void PlatformEGL::createContext(bool shared) {
     mAdditionalContexts.push_back(context);
 }
 
+void PlatformEGL::releaseContext() noexcept {
+    EGLContext context = eglGetCurrentContext();
+    eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    if (context != EGL_NO_CONTEXT) {
+        eglDestroyContext(mEGLDisplay, context);
+    }
+
+    mAdditionalContexts.erase(
+            std::remove_if(mAdditionalContexts.begin(), mAdditionalContexts.end(),
+                    [context](EGLContext c) {
+                        return c == context;
+                    }), mAdditionalContexts.end());
+
+    eglReleaseThread();
+}
+
 EGLBoolean PlatformEGL::makeCurrent(EGLSurface drawSurface, EGLSurface readSurface) noexcept {
     if (UTILS_UNLIKELY((drawSurface != mCurrentDrawSurface || readSurface != mCurrentReadSurface))) {
         mCurrentDrawSurface = drawSurface;
@@ -304,7 +320,8 @@ EGLBoolean PlatformEGL::makeCurrent(EGLSurface drawSurface, EGLSurface readSurfa
 }
 
 void PlatformEGL::terminate() noexcept {
-    eglMakeCurrent(mEGLDisplay, mEGLDummySurface, mEGLDummySurface, EGL_NO_CONTEXT);
+    // it's always allowed to use EGL_NO_SURFACE, EGL_NO_CONTEXT
+    eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
     if (mEGLDummySurface) {
         eglDestroySurface(mEGLDisplay, mEGLDummySurface);
     }