Skip to content

Preserve unsafe async reads with packed frame buffers #106

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
dgant wants to merge 1 commit into
base: implement-memory-safe
Choose a base branch
from
Open

Preserve unsafe async reads with packed frame buffers #106

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
221 changes: 0 additions & 221 deletions src/main/java/bwapi/AsyncClientData.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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);
}
}
}
2 changes: 1 addition & 1 deletion src/main/java/bwapi/ClientData.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
import com.sun.jna.Pointer;

class ClientData {
WrappedBuffer buffer;
volatile WrappedBuffer buffer;
GameData gameData;
ClientData() {
gameData = createGameData(0);
Expand Down
37 changes: 26 additions & 11 deletions src/main/java/bwapi/WrappedBuffer.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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.

@JasperGeurtz JasperGeurtz Nov 6, 2026 •
edited
Loading

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Do note that this approach requires quite a few branches, I'm not sure this is good for performance. @ Astra is there really no way to make the original approach work (fixing what was wrong), but making it really statically calculated offsets instead of these branches here?

@dgant dgant Nov 6, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

(Actually Dan) Yeah static offsets would be better. Will get you that.

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++;
Expand Down
Loading
Loading