Implemented partial frame copies, cutting about 3/4 off the amount of data we need to copy per frame

Author: dgant

src/main/java/bwapi/FrameBuffer.java

@@ -107,10 +107,19 @@ void enqueueFrame() {
                 performanceMetrics.intentionallyBlocking.stopTiming();
             } finally { lockSize.unlock(); };
 
-            performanceMetrics.copyingToBuffer.time(() -> {
-                ByteBuffer dataTarget = dataBuffer.get(indexGame());
-                copyBuffer(liveData, dataTarget);
-            });
+            // For the first frame of the game, populate all buffers completely
+            // This is to ensure all buffers have access to immutable data like regions/walkability/buildability
+            // Afterwards, we want to shorten this process by only copying important and mutable data
+            if (stepGame == 0) {
+                for (ByteBuffer frameBuffer : dataBuffer) {
+                    copyBuffer(liveData, frameBuffer, true);
+                }
+            } else {
+                performanceMetrics.copyingToBuffer.time(() -> {
+                    ByteBuffer dataTarget = dataBuffer.get(indexGame());
+                    copyBuffer(liveData, dataTarget, false);
+                });
+            }
 
             lockSize.lock();
             try {
@@ -144,31 +153,63 @@ void dequeue() {
         } finally { lockSize.unlock(); }
     }
 
-    void copyBuffer(ByteBuffer source, ByteBuffer destination) {
+    /**
+     *
+     * @param source Address to copy from
+     * @param destination Address to copy to
+     * @param size Number of bytes to copy
+     * @return True if the copy succeeded
+     */
+    private boolean tryMemcpyBuffer(ByteBuffer source, ByteBuffer destination, long offset, int size) {
+        long addressSource = ((DirectBuffer) source).address() + offset;
+        long addressDestination = ((DirectBuffer) destination).address() + offset;
+        try {
+            if (Platform.isWindows()) {
+                if (Platform.is64Bit()) {
+                    MSVCRT.INSTANCE.memcpy(addressDestination, addressSource, size);
+                    return true;
+                } else {
+                    MSVCRT.INSTANCE.memcpy((int) addressDestination, (int) addressSource, size);
+                    return true;
+                }
+            }
+        }
+        catch(Exception ignored) {}
+        return false;
+    }
+
+    void copyBuffer(ByteBuffer source, ByteBuffer destination, boolean copyEverything) {
         /*
         The speed at which we copy data into the frame buffer is a major cost of JBWAPI's asynchronous operation.
-        Copy times observed in the wild range from 2.6ms - 12ms.
+        Copy times observed in the wild usually range from 2.6ms - 19ms but are prone to large amounts of variance.
 
         The normal Java way to execute this copy is via ByteBuffer.put(), which has reasonably good performance characteristics.
         Some experiments in 64-bit JRE have shown that using a native memcpy achieves a 35% speedup.
         Some experiments in 32-bit JRE show no difference in performance.
 
         So, speculatively, we attempt to do a native memcpy.
-         */
-        long addressSource = ((DirectBuffer) source).address();
-        long addressDestination = ((DirectBuffer) destination).address();
-        try {
-            if (Platform.isWindows()) {
-                if (Platform.is64Bit()) {
-                    MSVCRT.INSTANCE.memcpy(addressDestination, addressSource, FrameBuffer.BUFFER_SIZE);
-                    return;
-                } else {
-                    MSVCRT.INSTANCE.memcpy((int) addressDestination, (int) addressSource, FrameBuffer.BUFFER_SIZE);
-                    return;
-                }
+        */
+
+        if (copyEverything) {
+            if (tryMemcpyBuffer(source, destination, 0, FrameBuffer.BUFFER_SIZE)) {
+                return;
+            }
+        } else {
+            int STATICTILES_START = 3447004; // getGroundHeight, isWalkable, isBuildable
+            int STATICTILES_END = 4823260;
+            int REGION_START = 5085404; // getMapTileRegionId, ..., getRegions
+            int REGION_END = 10586480;
+            int STRINGSSHAPES_START = 10962632; // getStringCount, ... getShapes
+            int STRINGSHAPES_END = 32242636;
+            int UNITFINDER_START = 32962644;
+            if (
+                tryMemcpyBuffer(source, destination, 0, STATICTILES_START)
+                && tryMemcpyBuffer(source, destination, STATICTILES_END, REGION_START - STATICTILES_END)
+                && tryMemcpyBuffer(source, destination, REGION_END, STRINGSSHAPES_START - REGION_END)
+                && tryMemcpyBuffer(source, destination, STRINGSHAPES_END, UNITFINDER_START - STRINGSHAPES_END)) {
+                return;
             }
         }
-        catch(Exception ignored) {}
 
         // There's no specific case where we expect to fail above,
         // but this is a safe fallback regardless,

src/test/java/bwapi/SynchronizationTest.java

@@ -195,7 +195,7 @@ public void async_MeasurePerformance_CopyingToBuffer() {
         SynchronizationEnvironment environment = new SynchronizationEnvironment();
         environment.configuration.async = true;
         environment.runGame(20);
-        final double minObserved = 2;
+        final double minObserved = 0.25;
         final double maxObserved = 15;
         final double meanObserved = (minObserved + maxObserved) / 2;
         final double rangeObserved = (maxObserved - minObserved) / 2;