Finished first pass async implementation, untested

Author: dgant

src/main/java/bwapi/BWClient.java

@@ -57,18 +57,19 @@ public void startGame(BWClientConfiguration configuration) {
                 }
                 client.update();
             }
-            botWrapper = new BotWrapper(configuration, client.mapFile(), client.gameData(), handler);
-            botWrapper.step();
+
+            botWrapper = new BotWrapper(configuration, client.mapFile(), client.clientData(), handler);
+
             while (getGame().isInGame()) {
-                client.update();
                 botWrapper.step();
+                client.update();
                 if (!client.isConnected()) {
                     System.out.println("Reconnecting...");
                     client.reconnect();
                 }
             }
 
-            // TODO: Before exiting give async bot time to complete onEnd().
+            // TODO: Before exiting give async bot time to complete onEnd(), maybe via thread.join().
 
         } while (configuration.autoContinue); // lgtm [java/constant-loop-condition]
 

src/main/java/bwapi/BWClientConfiguration.java

@@ -28,16 +28,11 @@ public class BWClientConfiguration {
      */
     public boolean async = false;
 
-    /**
-     * How frequently (in nanoseconds) to poll for the bot's event handlers completing. Acts as a floor on the bot's frame duration.
-     */
-    public int asyncFrameDurationNanosMin = 500;
-
     /**
      * If JBWAPI detects that this much time (in nanoseconds) has passed since a bot's event handlers began, returns control back to BWAPI.
      * Real-time human play typically uses the "fastest" game speed, which has 42.86ms (42,860ns) between frames.
      */
-    public int asyncFrameDurationNanosMax = 40000;
+    public int asyncFrameDurationNanos = 40000;
 
     /**
      * The maximum number of frames to buffer while waiting on a bot.
@@ -58,11 +53,8 @@ public class BWClientConfiguration {
      * Checks that the configuration is in a valid state. Throws an IllegalArgumentException if it isn't.
      */
     public void validate() {
-        if (async && asyncFrameDurationNanosMin <= 0) {
-            throw new IllegalArgumentException("asyncFrameDurationNanosMin needs to be a positive number (it's how long JBWAPI waits to poll for a completed frame.");
-        }
-        if (async && asyncFrameDurationNanosMax < 0) {
-            throw new IllegalArgumentException("asyncFrameDurationNanosMax needs to be a non-negative number (it's how long JBWAPI waits for a bot response before returning control to BWAPI).");
+        if (async && asyncFrameDurationNanos < 0) {
+            throw new IllegalArgumentException("asyncFrameDurationNanos needs to be a non-negative number (it's how long JBWAPI waits for a bot response before returning control to BWAPI).");
         }
         if (async && asyncFrameBufferSize < 1) {
             throw new IllegalArgumentException("asyncFrameBufferSize needs to be a positive number (There needs to be at least one frame buffer).");

src/main/java/bwapi/BotWrapper.java

@@ -30,36 +30,59 @@ of this software and associated documentation files (the "Software"), to deal
 /**
  * Manages invocation of bot event handlers
  */
-public class BotWrapper {
-    private BWClientConfiguration configuration;
-    private ByteBuffer sharedMemory;
-    private ClientData.GameData gameData;
-    private EventHandler eventHandler;
-    private FrameBuffer frameBuffer;
+class BotWrapper {
+    private final BWClientConfiguration configuration;
+    private final ByteBuffer sharedMemory;
+    private final ClientData clientData;
+    private final EventHandler eventHandler;
+    private final FrameBuffer frameBuffer;
+    private final Thread botThread;
 
-    public BotWrapper(
+    BotWrapper(
             BWClientConfiguration configuration,
             ByteBuffer sharedMemory,
-            ClientData.GameData gameData,
+            ClientData clientData,
             EventHandler eventHandler) {
         this.configuration = configuration;
         this.sharedMemory = sharedMemory;
-        this.gameData = gameData;
+        this.clientData = clientData;
         this.eventHandler = eventHandler;
 
         if (configuration.async) {
             frameBuffer = new FrameBuffer(configuration.asyncFrameBufferSize);
+            botThread = new Thread(() -> {
+                while(true) {
+                    while(frameBuffer.empty()) try {
+                        frameBuffer.wait();
+                    } catch (InterruptedException ignored) {}
+
+                    frameBuffer.dequeueFrame(clientData);
+                    handleEvents();
+                    if (!clientData.new GameData(0).isInGame()) {
+                        return;
+                    }
+                }
+            });
+        } else {
+            frameBuffer = null;
+            botThread = null;
         }
     }
 
-    public void step() {
+    void step() {
         if (configuration.async) {
-            // TODO: Synchronize
-            frameBuffer.enqueueFrame();
+            frameBuffer.enqueueFrame(sharedMemory);
+            frameBuffer.notifyAll();
         } else {
-            for (int i = 0; i < gameData.getEventCount(); i++) {
-                eventHandler.operation(gameData.getEvents(i));
-            }
+            handleEvents();
         }
     }
+
+    private void handleEvents() {
+        for (int i = 0; i < clientData.new GameData(0).getEventCount(); i++) {
+            eventHandler.operation(clientData.new GameData(0).getEvents(i));
+        }
+    }
+
+
 }

src/main/java/bwapi/FrameBuffer.java

@@ -26,10 +26,12 @@ of this software and associated documentation files (the "Software"), to deal
 package bwapi;
 
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Circular buffer of game states.
- * Doesn't attempt to manage overruns or synchronization.
  */
 public class FrameBuffer {
 
@@ -38,41 +40,73 @@ public class FrameBuffer {
     private int stepGame = 0;
     private int stepBot = 0;
 
+    // Synchronization locks
+    private Object stepCount;
+    private ArrayList<Lock> frameLocks;
+
     FrameBuffer(int size) {
         this.size = size;
         data = ByteBuffer.allocateDirect(size * ClientData.GameData.SIZE);
+        while (frameLocks.size() < size) {
+            frameLocks.add(new ReentrantLock());
+        }
     }
 
     /**
      * @return The number of frames currently buffered ahead of the bot's current frame
      */
-    public int framesBuffered() {
-        return stepGame - stepBot;
+    int framesBuffered() {
+        synchronized (stepCount) {
+            return stepGame - stepBot;
+        }
+    }
+
+    /**
+     * @return Whether the frame buffer is empty and has no frames available for the bot to consume.
+     */
+    boolean empty() {
+        synchronized (stepCount) {
+            return framesBuffered() <= 0;
+        }
     }
 
     /**
      * @return Whether the frame buffer is full and can not buffer any additional frames.
      * When the frame buffer is full, JBWAPI must wait for the bot to complete a frame before returning control to StarCraft.
      */
-    public boolean full() {
-        return framesBuffered() >= size - 1;
+    boolean full() {
+        synchronized (stepCount) {
+            return framesBuffered() >= size - 1;
+        }
     }
 
     /**
      * Copy data from shared memory into the head of the frame buffer.
-     * Does not attempt to check bounds or handle synchronization.
      */
-    public void enqueueFrame() {
-        // TODO: Enqueue
-        ++stepGame;
+    void enqueueFrame(ByteBuffer source) {
+        while(full()) try {
+            wait();
+        } catch (InterruptedException ignored) {}
+        synchronized (stepCount) {
+            data.put(source.array(), indexGame() * ClientData.GameData.SIZE, ClientData.GameData.SIZE);
+            ++stepGame;
+        }
+        notifyAll();
     }
 
     /**
      * Points the bot to the next frame in the buffer.
      */
-    public void dequeueFrame() {
-        // TODO: Dequeue
-        ++stepBot;
+    void dequeueFrame(ClientData clientData) {
+        while(empty()) try {
+            wait();
+        } catch (InterruptedException ignored) {}
+        synchronized (stepCount) {
+            clientData.setBuffer(data);
+            clientData.setBufferOffset(indexBot() * ClientData.GameData.SIZE);
+            ++stepBot;
+        }
+        notifyAll();
     }
 
     private int indexGame() {