fix: Update bindings and avoid per-frame allocation in debug renderer and task system

Author: Berstanio

gdx-box2d-utils/src/main/java/com/badlogic/gdx/box2d/utils/Box2dDebugRenderer.java

@@ -1,13 +1,12 @@
 package com.badlogic.gdx.box2d.utils;
 
 import com.badlogic.gdx.box2d.enums.b2HexColor;
-import com.badlogic.gdx.box2d.structs.b2DebugDraw;
-import com.badlogic.gdx.box2d.structs.b2Transform;
-import com.badlogic.gdx.box2d.structs.b2Vec2;
-import com.badlogic.gdx.box2d.structs.b2WorldId;
+import com.badlogic.gdx.box2d.structs.*;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.jnigen.runtime.closure.Closure;
 import com.badlogic.gdx.jnigen.runtime.closure.ClosureObject;
+import com.badlogic.gdx.jnigen.runtime.closure.PointingPoolManager;
 import com.badlogic.gdx.jnigen.runtime.pointer.VoidPointer;
 import com.badlogic.gdx.jnigen.runtime.pointer.integer.BytePointer;
 import com.badlogic.gdx.math.Matrix4;
@@ -18,23 +17,40 @@
 
 public class Box2dDebugRenderer implements Disposable {
 
+    private static final b2Vec2 TEMP_VEC_PTR = new b2Vec2(0L, false);
+    private static final b2Rot TEMP_ROT_PTR = new b2Rot(0L, false);
+
     private final ShapeRenderer renderer;
 
     private final b2DebugDraw b2DebugDraw;
+    private final PointingPoolManager pointingPoolManager;
 
     public Box2dDebugRenderer () {
+        pointingPoolManager = new PointingPoolManager(5);
+        pointingPoolManager.addPool(b2Vec2.b2Vec2Pointer::new, 5);
+        pointingPoolManager.addPool(VoidPointer::new, 5);
+        pointingPoolManager.addPool(b2Transform::new, 5);
+        pointingPoolManager.addPool(b2Vec2::new, 5);
+        pointingPoolManager.addPool(BytePointer::new, 5);
+
         renderer = new ShapeRenderer();
         renderer.setAutoShapeType(true);
         b2DebugDraw = b2DefaultDebugDraw();
-        b2DebugDraw.DrawPolygonFcn(ClosureObject.fromClosure(this::drawPolygon));
-        b2DebugDraw.DrawSolidPolygonFcn(ClosureObject.fromClosure(this::drawSolidPolygon));
-        b2DebugDraw.DrawCircleFcn(ClosureObject.fromClosure(this::drawCircle));
-        b2DebugDraw.DrawSolidCircleFcn(ClosureObject.fromClosure(this::drawSolidCircle));
-        b2DebugDraw.DrawSolidCapsuleFcn(ClosureObject.fromClosure(this::drawSolidCapsule));
-        b2DebugDraw.DrawSegmentFcn(ClosureObject.fromClosure(this::drawSegment));
-        b2DebugDraw.DrawTransformFcn(ClosureObject.fromClosure(this::drawTransform));
-        b2DebugDraw.DrawPointFcn(ClosureObject.fromClosure(this::drawPoint));
-        b2DebugDraw.DrawStringFcn(ClosureObject.fromClosure(this::drawString));
+        b2DebugDraw.DrawPolygonFcn(createPooledClosure(this::drawPolygon));
+        b2DebugDraw.DrawSolidPolygonFcn(createPooledClosure(this::drawSolidPolygon));
+        b2DebugDraw.DrawCircleFcn(createPooledClosure(this::drawCircle));
+        b2DebugDraw.DrawSolidCircleFcn(createPooledClosure(this::drawSolidCircle));
+        b2DebugDraw.DrawSolidCapsuleFcn(createPooledClosure(this::drawSolidCapsule));
+        b2DebugDraw.DrawSegmentFcn(createPooledClosure(this::drawSegment));
+        b2DebugDraw.DrawTransformFcn(createPooledClosure(this::drawTransform));
+        b2DebugDraw.DrawPointFcn(createPooledClosure(this::drawPoint));
+        b2DebugDraw.DrawStringFcn(createPooledClosure(this::drawString));
+    }
+
+    private <T extends Closure> ClosureObject<T> createPooledClosure(T closure) {
+        ClosureObject<T> closureObject = ClosureObject.fromClosure(closure);
+        closureObject.setPoolManager(pointingPoolManager);
+        return closureObject;
     }
 
     /** This assumes that the projection matrix has already been set. */
@@ -49,9 +65,9 @@ private void drawPolygon(b2Vec2.b2Vec2Pointer vertices, int vertexCount, b2HexCo
 
         float[] verticesArray = new float[vertexCount * 2];
         for (int i = 0; i < vertexCount; i++) {
-            b2Vec2 vec2 = vertices.asStackElement(i);
-            verticesArray[i * 2] = vec2.x();
-            verticesArray[i * 2 + 1] = vec2.y();
+            vertices.asStackElement(i, TEMP_VEC_PTR);
+            verticesArray[i * 2] = TEMP_VEC_PTR.x();
+            verticesArray[i * 2 + 1] = TEMP_VEC_PTR.y();
         }
         renderer.set(ShapeRenderer.ShapeType.Line);
         Box2dUtils.box2dColorToGDXColor(renderer.getColor(), color);
@@ -62,15 +78,18 @@ private void drawSolidPolygon(b2Transform transform, b2Vec2.b2Vec2Pointer vertic
         float[] verticesArray = new float[vertexCount * 2];
 
         for (int i = 0; i < vertexCount; i++) {
-            b2Vec2 vertex = vertices.asStackElement(i);
-            
-            float vx = vertex.x();
-            float vy = vertex.y();
+            vertices.asStackElement(i, TEMP_VEC_PTR);
 
-            float px = transform.p().x();
-            float py = transform.p().y();
-            float cos = transform.q().c();
-            float sin = transform.q().s();
+            float vx = TEMP_VEC_PTR.x();
+            float vy = TEMP_VEC_PTR.y();
+
+            transform.p(TEMP_VEC_PTR);
+            float px = TEMP_VEC_PTR.x();
+            float py = TEMP_VEC_PTR.y();
+
+            transform.q(TEMP_ROT_PTR);
+            float cos = TEMP_ROT_PTR.c();
+            float sin = TEMP_ROT_PTR.s();
 
             float x = px + cos * vx - sin * vy;
             float y = py + sin * vx + cos * vy;
@@ -100,7 +119,8 @@ private void drawCircle(b2Vec2 center, float radius, b2HexColor color, VoidPoint
     private void drawSolidCircle(b2Transform transform, float radius, b2HexColor color, VoidPointer context) {
         renderer.set(ShapeRenderer.ShapeType.Filled);
         Box2dUtils.box2dColorToGDXColor(renderer.getColor(), color);
-        renderer.circle(transform.p().x(), transform.p().y(), radius);
+        transform.p(TEMP_VEC_PTR);
+        renderer.circle(TEMP_VEC_PTR.x(), TEMP_VEC_PTR.y(), radius);
     }
 
     private void drawSolidCapsule(b2Vec2 p1, b2Vec2 p2, float radius, b2HexColor color, VoidPointer context) {
@@ -115,11 +135,13 @@ private void drawSegment(b2Vec2 p1, b2Vec2 p2, b2HexColor color, VoidPointer con
 
     private void drawTransform(b2Transform transform, VoidPointer context) {
         float axisScale = 0.4f;
-        
-        float px = transform.p().x();
-        float py = transform.p().y();
-        float cos = transform.q().c();
-        float sin = transform.q().s();
+
+        transform.p(TEMP_VEC_PTR);
+        transform.q(TEMP_ROT_PTR);
+        float px = TEMP_VEC_PTR.x();
+        float py = TEMP_VEC_PTR.y();
+        float cos = TEMP_ROT_PTR.c();
+        float sin = TEMP_ROT_PTR.s();
 
         renderer.set(ShapeRenderer.ShapeType.Line);
         renderer.setColor(Color.RED);

gdx-box2d-utils/src/main/java/com/badlogic/gdx/box2d/utils/Box2dWorldTaskSystem.java

@@ -3,13 +3,14 @@
 import com.badlogic.gdx.box2d.Box2d;
 import com.badlogic.gdx.box2d.structs.b2WorldDef;
 import com.badlogic.gdx.jnigen.runtime.closure.ClosureObject;
+import com.badlogic.gdx.jnigen.runtime.closure.PointingPoolManager;
 import com.badlogic.gdx.jnigen.runtime.pointer.VoidPointer;
 import com.badlogic.gdx.utils.Disposable;
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer;
 
 /**
  * This class implements a basic TaskSystem in java, for multithreading of a box2d world.
@@ -28,9 +29,13 @@ public class Box2dWorldTaskSystem implements Disposable {
     private final AtomicInteger aliveWorkers;
     private final Box2dWorldTaskSystemDeathHandler deathHandler;
     private final BlockingQueue<Box2dTaskChunk> taskChunks;
-    private final CountDownLatch[] countDownLatches = new CountDownLatch[MAX_TASKS];
+    private final Box2dCountdown[] countDownLatches = new Box2dCountdown[MAX_TASKS];
     private final ClosureObject<Box2d.b2EnqueueTaskCallback> enqueueTaskCallback;
     private final ClosureObject<Box2d.b2FinishTaskCallback> finishTaskCallback;
+    private final PointingPoolManager poolManager = new PointingPoolManager(2);
+    private final ArrayBlockingQueue<Box2dTaskChunk> chunkPool;
+    private final VoidPointer TASK_INDEX_WRAPPER = new VoidPointer(0L, false);
+    private final boolean poolingEnabled;
 
     private int taskCount = 0;
     private boolean running = true;
@@ -43,23 +48,31 @@ public class Box2dWorldTaskSystem implements Disposable {
      * @param worldDef The world to configure
      * @param numWorkers The amount of worker
      * @param deathHandler Handler for when the task system dies. see {@link Box2dWorldTaskSystemDeathHandler}
+     * @param enablePooling Whether the TaskSystem should avoid per-frame allocation
      * @return The created {@link Box2dWorldTaskSystem}
      */
-    public static Box2dWorldTaskSystem createForWorld(b2WorldDef worldDef, int numWorkers, Box2dWorldTaskSystemDeathHandler deathHandler) {
-        Box2dWorldTaskSystem multiThreader = new Box2dWorldTaskSystem(numWorkers, deathHandler);
+    public static Box2dWorldTaskSystem createForWorld(b2WorldDef worldDef, int numWorkers, Box2dWorldTaskSystemDeathHandler deathHandler, boolean enablePooling) {
+        Box2dWorldTaskSystem multiThreader = new Box2dWorldTaskSystem(numWorkers, deathHandler, enablePooling);
         multiThreader.configureForWorld(worldDef);
         return multiThreader;
     }
 
-    private Box2dWorldTaskSystem(int numWorkers, Box2dWorldTaskSystemDeathHandler deathHandler) {
+    private Box2dWorldTaskSystem(int numWorkers, Box2dWorldTaskSystemDeathHandler deathHandler, boolean enablePooling) {
         if (numWorkers <= 1)
             throw new IllegalArgumentException("Number of workers must be greater than 1");
+
+        this.poolingEnabled = enablePooling;
         this.numWorkers = numWorkers;
         this.workers = new Thread[numWorkers];
         this.taskChunks = new ArrayBlockingQueue<>(MAX_TASKS * numWorkers);
+        this.chunkPool = new ArrayBlockingQueue<>(MAX_TASKS * numWorkers);
         this.aliveWorkers = new AtomicInteger(numWorkers);
         this.deathHandler = deathHandler;
 
+        for (int i = 0; i < MAX_TASKS; i++) {
+            countDownLatches[i] = new Box2dCountdown();
+        }
+
         for (int i = 0; i < numWorkers; i++) {
             final int workerId = i;
             workers[i] = new Thread(() -> {
@@ -69,6 +82,8 @@ private Box2dWorldTaskSystem(int numWorkers, Box2dWorldTaskSystemDeathHandler de
                            Box2dTaskChunk task = taskChunks.take();
                            task.execute(workerId);
                            countDownLatches[task.taskIndex].countDown();
+                           if (poolingEnabled)
+                               chunkPool.offer(task);
                        } catch (InterruptedException e) {
                            break;
                        }
@@ -90,22 +105,26 @@ private Box2dWorldTaskSystem(int numWorkers, Box2dWorldTaskSystemDeathHandler de
                 int baseItemsPerTask = itemCount / numTasks;
                 int remainingItems = itemCount % numTasks;
 
-                countDownLatches[taskCount] = new CountDownLatch(numTasks);
+                countDownLatches[taskCount].setCount(numTasks);
 
                 int start = 0;
                 for (int i = 0; i < numTasks; i++) {
                     int itemsInThisTask = baseItemsPerTask + (i < remainingItems ? 1 : 0);
                     int end = start + itemsInThisTask;
 
-                    Box2dTaskChunk box2DTaskChunk = new Box2dTaskChunk(taskCount, task, start, end, taskContext);
+                    Box2dTaskChunk box2DTaskChunk = poolingEnabled ? chunkPool.poll() : new Box2dTaskChunk();
+                    if (box2DTaskChunk == null)
+                        box2DTaskChunk = new Box2dTaskChunk();
+
+                    box2DTaskChunk.setData(taskCount, task, start, end, taskContext.getPointer());
                     if (!taskChunks.offer(box2DTaskChunk))
                         throw new IllegalStateException("Task queue is full - impossible");
                     start = end;
                 }
 
-                VoidPointer taskIndex = new VoidPointer((long) taskCount + 1, false);
+                TASK_INDEX_WRAPPER.setPointer(taskCount + 1);
                 taskCount++;
-                return taskIndex;
+                return TASK_INDEX_WRAPPER;
             } else {
                 task.getClosure().b2TaskCallback_call(0, itemCount, 0, taskContext);
                 return VoidPointer.NULL;
@@ -119,11 +138,16 @@ private Box2dWorldTaskSystem(int numWorkers, Box2dWorldTaskSystemDeathHandler de
             int taskId = (int) userTask.getPointer() - 1;
             try {
                 countDownLatches[taskId].await();
-                countDownLatches[taskId] = null;
             } catch (InterruptedException e) {
                 throw new Box2dWorldTaskSystemInterruptException(e);
             }
         });
+
+        if (poolingEnabled) {
+            poolManager.addPool(VoidPointer::new, 2);
+            enqueueTaskCallback.setPoolManager(poolManager);
+            finishTaskCallback.setPoolManager(poolManager);
+        }
     }
 
     private void onThreadDies() {
@@ -166,18 +190,18 @@ public void dispose() {
     }
 
     private static class Box2dTaskChunk {
-        private final int taskIndex;
-        private final ClosureObject<Box2d.b2TaskCallback> task;
-        private final int start;
-        private final int end;
-        private final VoidPointer taskContext;
+        private int taskIndex;
+        private ClosureObject<Box2d.b2TaskCallback> task;
+        private int start;
+        private int end;
+        private final VoidPointer taskContext = new VoidPointer(0L, false);
 
-        public Box2dTaskChunk(int taskIndex, ClosureObject<Box2d.b2TaskCallback> task, int start, int end, VoidPointer taskContext) {
+        public void setData(int taskIndex, ClosureObject<Box2d.b2TaskCallback> task, int start, int end, long taskContext) {
             this.taskIndex = taskIndex;
             this.task = task;
             this.start = start;
             this.end = end;
-            this.taskContext = taskContext;
+            this.taskContext.setPointer(taskContext);
         }
 
         public void execute(int workerId) {
@@ -205,4 +229,41 @@ public interface Box2dWorldTaskSystemDeathHandler {
          */
         void taskSystemDied();
     }
+
+    private static class Box2dCountdown extends AbstractQueuedSynchronizer {
+
+        private Box2dCountdown() {
+            setState(0);
+        }
+
+        public void setCount(int count) {
+            setState(count);
+        }
+
+        public void await() throws InterruptedException {
+            acquireSharedInterruptibly(1);
+        }
+
+        public void countDown() {
+            releaseShared(1);
+        }
+
+        @Override
+        protected int tryAcquireShared(int acquires) {
+            return (getState() == 0) ? 1 : -1;
+        }
+
+        @Override
+        protected boolean tryReleaseShared(int releases) {
+            // Decrement count; signal when transition to zero
+            for (;;) {
+                int c = getState();
+                if (c == 0)
+                    return false;
+                int nextc = c - 1;
+                if (compareAndSetState(c, nextc))
+                    return nextc == 0;
+            }
+        }
+    }
 }

gdx-box2d-utils/src/test/java/com/badlogic/gdx/box2d/utils/test/Box2dWorldTaskSystemTest.java

@@ -22,7 +22,7 @@ public static void tiltedStacks(int testIndex, int workerCount, b2Vec2[][] final
         Box2dWorldTaskSystem multiThreader = null;
         if (workerCount > 1) {
             Thread currentThread = Thread.currentThread();
-            multiThreader = Box2dWorldTaskSystem.createForWorld(worldDef, workerCount, currentThread::interrupt);
+            multiThreader = Box2dWorldTaskSystem.createForWorld(worldDef, workerCount, currentThread::interrupt, true);
         }
 
         b2WorldId worldId = b2CreateWorld(worldDef.asPointer());