Keep unsafe async accesses consistent across packed buffer handoffs

Author: dgant

src/main/java/bwapi/AsyncClientData.java

@@ -60,18 +60,6 @@ class AsyncGameData extends GameData {
             super(myOffset);
         }
 
-        private int deltaRange2() {
-            return buffer != null && buffer.isPacked() ? DELTA_RANGE2 : 0;
-        }
-
-        private int deltaRange3() {
-            return buffer != null && buffer.isPacked() ? DELTA_RANGE3 : 0;
-        }
-
-        private int deltaRange4() {
-            return buffer != null && buffer.isPacked() ? DELTA_RANGE4 : 0;
-        }
-
         @Override
         int getGroundHeight(int i, int j) {
             int offset = myOffset + 3447004 + 4 * 1 * j + 4 * 256 * i;
@@ -100,42 +88,6 @@ void setIsBuildable(int i, int j, boolean value) {
             getStaticBuffer().putByte(myOffset + 4757724 + 1 * 1 * j + 1 * 256 * i, (byte) (value ? 1 : 0));
         }
         @Override
-        boolean isVisible(int i, int j) {
-            int offset = myOffset + 4823260 - deltaRange2() + 1 * 1 * j + 1 * 256 * i;
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsVisible(int i, int j, boolean value) {
-            buffer.putByte(myOffset + 4823260 - deltaRange2() + 1 * 1 * j + 1 * 256 * i, (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isExplored(int i, int j) {
-            int offset = myOffset + 4888796 - deltaRange2() + 1 * 1 * j + 1 * 256 * i;
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsExplored(int i, int j, boolean value) {
-            buffer.putByte(myOffset + 4888796 - deltaRange2() + 1 * 1 * j + 1 * 256 * i, (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean getHasCreep(int i, int j) {
-            int offset = myOffset + 4954332 - deltaRange2() + 1 * 1 * j + 1 * 256 * i;
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setHasCreep(int i, int j, boolean value) {
-            buffer.putByte(myOffset + 4954332 - deltaRange2() + 1 * 1 * j + 1 * 256 * i, (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isOccupied(int i, int j) {
-            int offset = myOffset + 5019868 - deltaRange2() + 1 * 1 * j + 1 * 256 * i;
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsOccupied(int i, int j, boolean value) {
-            buffer.putByte(myOffset + 5019868 - deltaRange2() + 1 * 1 * j + 1 * 256 * i, (byte) (value ? 1 : 0));
-        }
-        @Override
         short getMapTileRegionId(int i, int j) {
             int offset = myOffset + 5085404 + 2 * 1 * j + 2 * 256 * i;
             return getStaticBuffer().getShort(offset);
@@ -185,178 +137,5 @@ RegionData getRegions(int i) {
             int offset = myOffset + 5246480 + 1068 * 1 * i;
             return new RegionData(offset);
         }
-        @Override
-        int getStartLocationCount() {
-            int offset = myOffset + 10586480 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setStartLocationCount(int value) {
-            buffer.putInt(myOffset + 10586480 - deltaRange3(), value);
-        }
-        @Override
-        Position getStartLocations(int i) {
-            int offset = myOffset + 10586484 - deltaRange3() + 8 * 1 * i;
-            return new Position(offset);
-        }
-        @Override
-        boolean isInGame() {
-            int offset = myOffset + 10586548 - deltaRange3();
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsInGame(boolean value) {
-            buffer.putByte(myOffset + 10586548 - deltaRange3(), (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isMultiplayer() {
-            int offset = myOffset + 10586549 - deltaRange3();
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsMultiplayer(boolean value) {
-            buffer.putByte(myOffset + 10586549 - deltaRange3(), (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isBattleNet() {
-            int offset = myOffset + 10586550 - deltaRange3();
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsBattleNet(boolean value) {
-            buffer.putByte(myOffset + 10586550 - deltaRange3(), (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isPaused() {
-            int offset = myOffset + 10586551 - deltaRange3();
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsPaused(boolean value) {
-            buffer.putByte(myOffset + 10586551 - deltaRange3(), (byte) (value ? 1 : 0));
-        }
-        @Override
-        boolean isReplay() {
-            int offset = myOffset + 10586552 - deltaRange3();
-            return buffer.getByte(offset) != 0;
-        }
-        @Override
-        void setIsReplay(boolean value) {
-            buffer.putByte(myOffset + 10586552 - deltaRange3(), (byte) (value ? 1 : 0));
-        }
-        @Override
-        int getSelectedUnitCount() {
-            int offset = myOffset + 10586556 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setSelectedUnitCount(int value) {
-            buffer.putInt(myOffset + 10586556 - deltaRange3(), value);
-        }
-        @Override
-        int getSelectedUnits(int i) {
-            int offset = myOffset + 10586560 - deltaRange3() + 4 * 1 * i;
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setSelectedUnits(int i, int value) {
-            buffer.putInt(myOffset + 10586560 - deltaRange3() + 4 * 1 * i, value);
-        }
-        @Override
-        int getSelf() {
-            int offset = myOffset + 10586608 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setSelf(int value) {
-            buffer.putInt(myOffset + 10586608 - deltaRange3(), value);
-        }
-        @Override
-        int getEnemy() {
-            int offset = myOffset + 10586612 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setEnemy(int value) {
-            buffer.putInt(myOffset + 10586612 - deltaRange3(), value);
-        }
-        @Override
-        int getNeutral() {
-            int offset = myOffset + 10586616 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setNeutral(int value) {
-            buffer.putInt(myOffset + 10586616 - deltaRange3(), value);
-        }
-        @Override
-        int getEventCount() {
-            int offset = myOffset + 10586620 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setEventCount(int value) {
-            buffer.putInt(myOffset + 10586620 - deltaRange3(), value);
-        }
-        @Override
-        Event getEvents(int i) {
-            int offset = myOffset + 10586624 - deltaRange3() + 12 * 1 * i;
-            return new Event(offset);
-        }
-        @Override
-        int getEventStringCount() {
-            int offset = myOffset + 10706624 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setEventStringCount(int value) {
-            buffer.putInt(myOffset + 10706624 - deltaRange3(), value);
-        }
-        @Override
-        String getEventStrings(int i) {
-            int offset = myOffset + 10706628 - deltaRange3() + 1 * 256 * i;
-            return buffer.getString(offset, 256);
-        }
-        @Override
-        void setEventStrings(int i, String value) {
-            buffer.putString(myOffset + 10706628 - deltaRange3() + 1 * 256 * i, 256, value);
-        }
-        @Override
-        int getStringCount() {
-            int offset = myOffset + 10962628 - deltaRange3();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setStringCount(int value) {
-            buffer.putInt(myOffset + 10962628 - deltaRange3(), value);
-        }
-        @Override
-        int getCommandCount() {
-            int offset = myOffset + 32242636 - deltaRange4();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setCommandCount(int value) {
-            buffer.putInt(myOffset + 32242636 - deltaRange4(), value);
-        }
-        @Override
-        Command getCommands(int i) {
-            int offset = myOffset + 32242640 - deltaRange4() + 12 * 1 * i;
-            return new Command(offset);
-        }
-        @Override
-        int getUnitCommandCount() {
-            int offset = myOffset + 32482640 - deltaRange4();
-            return buffer.getInt(offset);
-        }
-        @Override
-        void setUnitCommandCount(int value) {
-            buffer.putInt(myOffset + 32482640 - deltaRange4(), value);
-        }
-        @Override
-        UnitCommand getUnitCommands(int i) {
-            int offset = myOffset + 32482644 - deltaRange4() + 24 * 1 * i;
-            return new UnitCommand(offset);
-        }
     }
 }

src/main/java/bwapi/ClientData.java

@@ -3,7 +3,7 @@
 import com.sun.jna.Pointer;
 
 class ClientData {
-    WrappedBuffer buffer;
+    volatile WrappedBuffer buffer;
     GameData gameData;
     ClientData() {
         gameData = createGameData(0);

src/main/java/bwapi/WrappedBuffer.java

@@ -35,52 +35,67 @@ boolean isPacked() {
         return packed;
     }
 
+    private long addressAt(int offset) {
+        // Translate on the selected buffer: unsafe async can switch layouts during a read.
+        if (packed && offset >= AsyncClientData.STATICTILES_END) {
+            if (offset >= AsyncClientData.STATICTILES_END && offset < AsyncClientData.REGION_START) {
+                offset -= AsyncClientData.DELTA_RANGE2;
+            } else if (offset >= AsyncClientData.REGION_END && offset < AsyncClientData.STRINGSSHAPES_START) {
+                offset -= AsyncClientData.DELTA_RANGE3;
+            } else if (offset >= AsyncClientData.STRINGSHAPES_END && offset < AsyncClientData.UNITFINDER_START) {
+                offset -= AsyncClientData.DELTA_RANGE4;
+            }
+        }
+        return address + offset;
+    }
+
     byte getByte(final int offset) {
-        return unsafe.getByte(address + offset);
+        return unsafe.getByte(addressAt(offset));
     }
 
     void putByte(final int offset, final byte value) {
-        unsafe.putByte(address + offset, value);
+        unsafe.putByte(addressAt(offset), value);
     }
 
     short getShort(final int offset) {
-        return unsafe.getShort(address + offset);
+        return unsafe.getShort(addressAt(offset));
     }
 
     void putShort(final int offset, final short value) {
-        unsafe.putShort(address + offset, value);
+        unsafe.putShort(addressAt(offset), value);
     }
 
     int getInt(final int offset) {
-        return unsafe.getInt(address + offset);
+        return unsafe.getInt(addressAt(offset));
     }
 
     void putInt(final int offset, final int value) {
-        unsafe.putInt(address + offset, value);
+        unsafe.putInt(addressAt(offset), value);
     }
 
     double getDouble(final int offset) {
-        return unsafe.getDouble(address + offset);
+        return unsafe.getDouble(addressAt(offset));
     }
 
     void putDouble(final int offset, final double value) {
-        unsafe.putDouble(address + offset, value);
+        unsafe.putDouble(addressAt(offset), value);
     }
 
     String getString(final int offset, final int maxLen) {
         final char[] buf = new char[maxLen];
-        long pos = offset + address;
+        final long start = addressAt(offset);
+        long pos = start;
         for (int i = 0; i < maxLen; i++) {
             byte b = unsafe.getByte(pos);
             if (b == 0) break;
             buf[i] = (char) (b & 0xff);
             pos++;
         }
-        return new String(buf, 0, (int) (pos - offset - address));
+        return new String(buf, 0, (int) (pos - start));
     }
 
     void putString(final int offset, final int maxLen, final String string) {
-        long pos = offset + address;
+        long pos = addressAt(offset);
         for (int i = 0; i < Math.min(string.length(), maxLen - 1); i++) {
             unsafe.putByte(pos, (byte) string.charAt(i));
             pos++;