wrappedbuffer-with-offsets

Author: Jasper Geurtz

src/main/java/bwapi/BotWrapperAsync.java

@@ -22,26 +22,25 @@ class BotWrapperAsync extends BotWrapper {
         // Use reduced priority to encourage Windows to give priority to StarCraft.exe/BWAPI.
         // If BWAPI doesn't get priority, it may not detect completion of a frame on our end in timely fashion.
         Thread.currentThread().setName("JBWAPI Client");
-        Thread.currentThread().setPriority(Thread.NORM_PRIORITY - 1);
+        Thread.currentThread().setPriority(4);
     }
 
     /**
      * Resets the BotWrapper for a new botGame.
      */
     void startNewGame(WrappedBuffer liveData, PerformanceMetrics performanceMetrics) {
-        frameBuffer.initialize(liveData, performanceMetrics);
-
         super.startNewGame(liveData, performanceMetrics);
+
+        frameBuffer.initialize(liveData, performanceMetrics);
         liveClientData.setBuffer(liveData);
         this.liveData = liveData;
 
-//        configuration.log("Main: Starting bot thread");
-//        botThread = createBotThread();
-//        botThread.setName("JBWAPI Bot");
-//        // Reduced priority helps ensure that StarCraft.exe/BWAPI pick up on our frame completion in timely fashion
-//        botThread.setPriority(Thread.NORM_PRIORITY - 2);
-//        botThread.start();
-        botThread = null;
+        configuration.log("Main: Starting bot thread");
+        botThread = createBotThread();
+        botThread.setName("JBWAPI Bot");
+        // Reduced priority helps ensure that StarCraft.exe/BWAPI pick up on our frame completion in timely fashion
+        botThread.setPriority(3);
+        botThread.start();
     }
 
 
@@ -82,15 +81,6 @@ void asyncOnFrame() {
         long startNanos = System.nanoTime();
         long endNanos = startNanos + (long) configuration.getMaxFrameDurationMs() * 1000000;
 
-        if (botThread == null) {
-            configuration.log("Main: Starting bot thread");
-            botThread = createBotThread();
-            botThread.setName("JBWAPI Bot");
-            // Reduced priority helps ensure that StarCraft.exe/BWAPI pick up on our frame completion in timely fashion
-            botThread.setPriority(3);
-            botThread.start();
-        }
-
         // Unsafe mode:
         // If the frame buffer is empty (meaning the bot must be idle)
         // allow the bot to read directly from shared memory while we copy it over

src/main/java/bwapi/FrameBuffer.java

@@ -1,7 +1,5 @@
 package bwapi;
 
-import sun.misc.Unsafe;
-
 import java.util.ArrayList;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
@@ -11,16 +9,12 @@
  * Circular buffer of game states.
  */
 class FrameBuffer {
-    private static final int BUFFER_SIZE = ClientData.GameData.SIZE;
-    private static final Unsafe unsafe = UnsafeTools.getUnsafe();
-
-    private WrappedBuffer liveData;
     private PerformanceMetrics performanceMetrics;
     private final BWClientConfiguration configuration;
     private final int capacity;
     private int stepGame = 0;
     private int stepBot = 0;
-    private final ArrayList<WrappedBuffer> dataBuffer = new ArrayList<>();
+    private final ArrayList<WrappedBufferOffset> dataBuffer = new ArrayList<>();
 
     private final Lock lockWrite = new ReentrantLock();
     final Lock lockSize = new ReentrantLock();
@@ -30,18 +24,18 @@ class FrameBuffer {
         this.capacity = configuration.getAsyncFrameBufferCapacity();
         this.configuration = configuration;
         while(dataBuffer.size() < capacity) {
-            dataBuffer.add(new WrappedBuffer(BUFFER_SIZE));
+            dataBuffer.add(new WrappedBufferOffset());
         }
     }
 
     /**
      * Resets for a new game
      */
     void initialize(WrappedBuffer liveData, PerformanceMetrics performanceMetrics) {
-        this.liveData = liveData;
         this.performanceMetrics = performanceMetrics;
         stepGame = 0;
         stepBot = 0;
+        dataBuffer.forEach(b -> b.setSourceBuffer(liveData));
     }
 
     /**
@@ -107,19 +101,10 @@ void enqueueFrame() {
                 performanceMetrics.getIntentionallyBlocking().stopTiming();
             } finally { lockSize.unlock(); };
 
-            // 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 (WrappedBuffer frameBuffer : dataBuffer) {
-                    copyBuffer(liveData, frameBuffer, true);
-                }
-            } else {
-                performanceMetrics.getCopyingToBuffer().time(() -> {
-                    WrappedBuffer dataTarget = dataBuffer.get(indexGame());
-                    copyBuffer(liveData, dataTarget, false);
-                });
-            }
+            performanceMetrics.getCopyingToBuffer().time(() -> {
+                WrappedBufferOffset dataTarget = dataBuffer.get(indexGame());
+                dataTarget.initialize();
+            });
 
             lockSize.lock();
             try {
@@ -152,46 +137,4 @@ void dequeue() {
             conditionSize.signalAll();
         } finally { lockSize.unlock(); }
     }
-
-    /**
-     *
-     * @param source Address to copy from
-     * @param destination Address to copy to
-     * @param size Number of bytes to copy
-     */
-    private void copyBuffer(WrappedBuffer source, WrappedBuffer destination, long offset, int size) {
-        long addressSource = source.getAddress() + offset;
-        long addressDestination = destination.getAddress() + offset;
-        unsafe.copyMemory(addressSource, addressDestination, size);
-    }
-
-    void copyBuffer(WrappedBuffer source, WrappedBuffer 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 for the complete buffer 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.
-        */
-
-        if (copyEverything) {
-            copyBuffer(source, destination, 0, FrameBuffer.BUFFER_SIZE);
-        } else {
-            // After the buffer has been filled the first time,
-            // we can omit copying blocks of data which are unused or which don't change after game start.
-            // These blocks account for *most* of the 33MB shared memory,
-            // so omitting them drastically reduces the copy duration
-            final int STATICTILES_START = 3447004; // getGroundHeight, isWalkable, isBuildable
-            final int STATICTILES_END = 4823260;
-            final int REGION_START = 5085404; // getMapTileRegionId, ..., getRegions
-            final int REGION_END = 10586480;
-            final int STRINGSSHAPES_START = 10962632; // getStringCount, ... getShapes
-            final int STRINGSHAPES_END = 32242636;
-            final int UNITFINDER_START = 32962644;
-            copyBuffer(source, destination, 0, STATICTILES_START);
-            copyBuffer(source, destination, STATICTILES_END, REGION_START - STATICTILES_END);
-            copyBuffer(source, destination, REGION_END, STRINGSSHAPES_START - REGION_END);
-            copyBuffer(source, destination, STRINGSHAPES_END, UNITFINDER_START - STRINGSHAPES_END);
-        }
-    }
 }

src/main/java/bwapi/WrappedBufferOffset.java

@@ -6,9 +6,7 @@
  * <p> </p>For now this hardcodes a few things (size, offsets).
  */
 class WrappedBufferOffset extends WrappedBuffer {
-    // The "real" WrappedBuffer that contains the dynamic & static values.
-    // WrappedBufferOffset makes a copy of the dynamic ones, but delegates
-    // to the "real" one for the static values. This saves a lot of memory.
+
     private WrappedBuffer sourceBuffer;
 
     WrappedBufferOffset() {
@@ -165,7 +163,7 @@ static final class DynamicData {
         static int offset(int offset) {
             for (MemRegion r : MEM_REGIONS) {
                 if (offset >= r.start && offset < r.end) {
-                    return offset - r.offset;
+                    return r.offset + (offset - r.start);
                 }
             }
             return -1;