chore: improve swap chain performance by reducing synchronization needs

Author: silenium-dev

src/main/java/dev/silenium/compose/gl/fbo/FBOFifoSwapChain.kt

@@ -1,59 +1,73 @@
 package dev.silenium.compose.gl.fbo
 
 import androidx.compose.ui.unit.IntSize
-import java.util.concurrent.ArrayBlockingQueue
-import java.util.concurrent.locks.ReentrantLock
-import kotlin.concurrent.withLock
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicReference
 
-class FBOFifoSwapChain(capacity: Int, override val fboCreator: (IntSize) -> FBO) : FBOSwapChain() {
+class FBOFifoSwapChain(private val capacity: Int, override val fboCreator: (IntSize) -> FBO) : FBOSwapChain() {
     override var size: IntSize = IntSize.Zero
         private set
-    private val displayLock = ReentrantLock()
-    private var current: FBO? = null
-    private val renderQueue = ArrayBlockingQueue<FBO>(capacity)
-    private val displayQueue = ArrayBlockingQueue<FBO>(capacity)
+    private var fbos = AtomicReference<Array<FBO>?>(null)
+    private var current: Int = -1
+    private val displayQueue = ConcurrentLinkedQueue<Int>()
+    private val renderQueue = ConcurrentLinkedQueue<Int>()
 
-    override fun <R> display(block: (FBO) -> R) = displayLock.withLock {
-        val result = current?.let(block)
-        if (!displayQueue.isEmpty()) {
-            current?.let {
-                if (it.size != size) it.destroy()
-                else renderQueue.offer(it)
-            }
-            current = displayQueue.poll()
+    override fun <R> display(block: (FBO) -> R): R? {
+        val next = displayQueue.poll()
+        if (next != null && next != -1) {
+            renderQueue.add(current)
+            current = next
         }
-        return@withLock result
+        if (current == -1) return null
+        val fbo = fbos.get()?.get(current) ?: return null
+        val result = block(fbo)
+        return result
     }
 
     override fun <R> render(block: (FBO) -> R): R? {
-        val fbo = renderQueue.poll() ?: return null
-        if (fbo.size != size) {
-            fbo.destroy()
-            return null
+        val next = renderQueue.poll() ?: return null
+        val nextFbos = fbos.updateAndGet {
+            if (it?.get(next)?.size != size) {
+                it?.get(next)?.destroy()
+                it?.set(next, fboCreator(size))
+            }
+            it
         }
         try {
-            val result = block(fbo)
-            displayQueue.offer(fbo)
+            val nextFbo = nextFbos?.get(next) ?: return null
+            val result = block(nextFbo)
+            current = next
             return result
         } catch (e: Throwable) {
-            renderQueue.add(fbo)
             throw e
         }
     }
 
     override fun resize(size: IntSize) {
         this.size = size
-        renderQueue.onEach { it.destroy() }.clear()
-        displayQueue.onEach { it.destroy() }.clear()
-        renderQueue.fillRenderQueue(fboCreator, size)
+        renderQueue.clear()
+        displayQueue.clear()
+        fbos.get()?.forEachIndexed { index, fbo ->
+            if (fbo.size != size && index != current) {
+                fbo.destroy()
+            }
+        }
+        val currentFbo = fbos.get()?.getOrNull(current)
+        fbos.set(Array(capacity) {
+            if (it == current) currentFbo ?: fboCreator(size)
+            else fboCreator(size)
+        }.also {
+            renderQueue.addAll(it.indices - current)
+        })
     }
 
     override fun destroyFBOs() {
-        renderQueue.onEach { it.destroy() }.clear()
-        displayQueue.onEach { it.destroy() }.clear()
-        displayLock.withLock {
-            current?.destroy()
-            current = null
+        renderQueue.clear()
+        displayQueue.clear()
+        current = -1
+        fbos.updateAndGet {
+            it?.forEach(FBO::destroy)
+            null
         }
     }
 }

src/main/java/dev/silenium/compose/gl/fbo/FBOMailboxSwapChain.kt

@@ -1,47 +1,59 @@
 package dev.silenium.compose.gl.fbo
 
 import androidx.compose.ui.unit.IntSize
-import java.util.concurrent.locks.ReentrantReadWriteLock
-import kotlin.concurrent.read
-import kotlin.concurrent.write
+import java.util.concurrent.atomic.AtomicReference
 
 class FBOMailboxSwapChain(private val capacity: Int, override val fboCreator: (IntSize) -> FBO) : FBOSwapChain() {
     override var size: IntSize = IntSize.Zero
         private set
-    private val stateLock = ReentrantReadWriteLock()
-    private var fbos: Array<FBO>? = null
+    private var fbos = AtomicReference<Array<FBO>?>(null)
     private var current: Int = -1
 
-    override fun <R> display(block: (FBO) -> R): R? = stateLock.read stateLock@{
-        if (current == -1) return@stateLock null
-        val fbo = fbos?.get(current) ?: return@stateLock null
+    override fun <R> display(block: (FBO) -> R): R? {
+        if (current == -1) return null
+        val fbo = fbos.get()?.get(current) ?: return null
         val result = block(fbo)
-        return@stateLock result
+        return result
     }
 
-    override fun <R> render(block: (FBO) -> R): R? = stateLock.read {
-        val fbos = fbos ?: return null
-        val next = (current + 1) % fbos.size
-        if (fbos[next].size != size) {
-            fbos[next].destroy()
-            fbos[next] = fboCreator(size)
+    override fun <R> render(block: (FBO) -> R): R? {
+        val next = (current + 1) % capacity
+        val nextFbos = fbos.updateAndGet {
+            if (it?.get(next)?.size != size) {
+                it?.get(next)?.destroy()
+                it?.set(next, fboCreator(size))
+            }
+            it
         }
         try {
-            val result = block(fbos[next])
+            val nextFbo = nextFbos?.get(next) ?: return null
+            val result = block(nextFbo)
             current = next
             return result
         } catch (e: Throwable) {
             throw e
         }
     }
 
-    override fun resize(size: IntSize): Unit = stateLock.write {
+    override fun resize(size: IntSize) {
         this.size = size
-        fbos?.forEach(FBO::destroy)
-        fbos = Array(capacity) { fboCreator(size) }
+        fbos.get()?.forEachIndexed { index, fbo ->
+            if (fbo.size != size && index != current) {
+                fbo.destroy()
+            }
+        }
+        val currentFbo = fbos.get()?.getOrNull(current)
+        fbos.set(Array(capacity) {
+            if (it == current) currentFbo ?: fboCreator(size)
+            else fboCreator(size)
+        })
     }
 
-    override fun destroyFBOs(): Unit = stateLock.write {
-        fbos?.forEach(FBO::destroy)
+    override fun destroyFBOs() {
+        current = -1
+        fbos.updateAndGet {
+            it?.forEach(FBO::destroy)
+            null
+        }
     }
 }