From 6364f59ac40ecad5eea3b2691fc8dd8f7582f008 Mon Sep 17 00:00:00 2001
From: Travis Watkins <amaranth@ubuntu.com>
Date: Sat, 21 Jun 2014 11:38:28 -0500
Subject: [PATCH] Use compact memory format for uniform chunk section data.
Many chunk sections contain parts of their data that are the same for
every block they contain. In these cases we can save memory by saving
a single value instead of an array of 4096 copies of that value. Block light
and block data are most likely to be uniform followed closely by sky light
data. Block ids are far less likely to be uniform but give the largest
saving when they are. Because of this we use a compact format for every
part of the chunk. Memory saved from this technique will vary based on the
world but seems to be about 50% on normal Minecraft generated chunks.
---
.../net/minecraft/server/ChunkSection.java | 331 ++++++++++++++----
1 file changed, 272 insertions(+), 59 deletions(-)
diff --git a/src/main/java/net/minecraft/server/ChunkSection.java b/src/main/java/net/minecraft/server/ChunkSection.java
index a05efa0166..787077dcd1 100644
--- a/src/main/java/net/minecraft/server/ChunkSection.java
+++ b/src/main/java/net/minecraft/server/ChunkSection.java
@@ -1,5 +1,7 @@
package net.minecraft.server;
+import java.util.Arrays; // CraftBukkit
+
public class ChunkSection {
private int yPos;
@@ -10,34 +12,83 @@ public class ChunkSection {
private NibbleArray blockData;
private NibbleArray emittedLight;
private NibbleArray skyLight;
+ // CraftBukkit start - Compact storage
+ private byte compactId;
+ private byte compactExtId;
+ private byte compactData;
+ private byte compactEmitted;
+ private byte compactSky;
+
+ // Pre-generated (read-only!) NibbleArrays for every possible value, used for chunk saving
+ private static NibbleArray[] compactPregen = new NibbleArray[16];
+ static {
+ for (int i = 0; i < 16; i++) {
+ compactPregen[i] = expandCompactNibble((byte) i);
+ }
+ }
+
+ private static NibbleArray expandCompactNibble(byte value) {
+ byte[] data = new byte[2048];
+ Arrays.fill(data, (byte) (value | (value << 4)));
+ return new NibbleArray(data, 4);
+ }
+
+ private boolean canBeCompact(byte[] array) {
+ byte value = array[0];
+ for (int i = 1; i < array.length; i++) {
+ if (value != array[i]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ // CraftBukkit end
public ChunkSection(int i, boolean flag) {
this.yPos = i;
+ /* CraftBukkit - Start as null, using compact storage
this.blockIds = new byte[4096];
this.blockData = new NibbleArray(this.blockIds.length, 4);
this.emittedLight = new NibbleArray(this.blockIds.length, 4);
if (flag) {
this.skyLight = new NibbleArray(this.blockIds.length, 4);
}
+ */
+ if (!flag) {
+ this.compactSky = -1;
+ }
+ // CraftBukkit end
}
// CraftBukkit start
public ChunkSection(int y, boolean flag, byte[] blkIds, byte[] extBlkIds) {
this.yPos = y;
- this.blockIds = blkIds;
+ this.setIdArray(blkIds);
if (extBlkIds != null) {
- this.extBlockIds = new NibbleArray(extBlkIds, 4);
+ this.setExtendedIdArray(new NibbleArray(extBlkIds, 4));
}
- this.blockData = new NibbleArray(this.blockIds.length, 4);
- this.emittedLight = new NibbleArray(this.blockIds.length, 4);
- if (flag) {
- this.skyLight = new NibbleArray(this.blockIds.length, 4);
+ if (!flag) {
+ this.compactSky = -1;
}
this.recalcBlockCounts();
}
// CraftBukkit end
public Block getTypeId(int i, int j, int k) {
+ // CraftBukkit start - Compact storage
+ if (this.blockIds == null) {
+ int id = this.compactId;
+ if (this.extBlockIds == null) {
+ id |= this.compactExtId << 8;
+ } else {
+ id |= this.extBlockIds.a(i, j, k) << 8;
+ }
+
+ return Block.e(id); // Should be getBlockForId
+ }
+ // CraftBukkit end
+
int l = this.blockIds[j << 8 | k << 4 | i] & 255;
if (this.extBlockIds != null) {
@@ -48,13 +99,12 @@ public class ChunkSection {
}
public void setTypeId(int i, int j, int k, Block block) {
- int l = this.blockIds[j << 8 | k << 4 | i] & 255;
-
- if (this.extBlockIds != null) {
- l |= this.extBlockIds.a(i, j, k) << 8;
+ // CraftBukkit start - Compact storage
+ Block block1 = this.getTypeId(i, j, k);
+ if (block == block1) {
+ return;
}
-
- Block block1 = Block.e(l);
+ // CraftBukkit end
if (block1 != Blocks.AIR) {
--this.nonEmptyBlockCount;
@@ -72,10 +122,17 @@ public class ChunkSection {
int i1 = Block.b(block);
+ // CraftBukkit start - Compact storage
+ if (this.blockIds == null) {
+ this.blockIds = new byte[4096];
+ Arrays.fill(this.blockIds, this.compactId);
+ }
+ // CraftBukkit end
+
this.blockIds[j << 8 | k << 4 | i] = (byte) (i1 & 255);
if (i1 > 255) {
if (this.extBlockIds == null) {
- this.extBlockIds = new NibbleArray(this.blockIds.length, 4);
+ this.extBlockIds = expandCompactNibble(this.compactExtId); // CraftBukkit - Compact storage
}
this.extBlockIds.a(i, j, k, (i1 & 3840) >> 8);
@@ -85,10 +142,23 @@ public class ChunkSection {
}
public int getData(int i, int j, int k) {
+ // CraftBukkit start - Compact storage
+ if (this.blockData == null) {
+ return this.compactData;
+ }
+ // CraftBukkit end
return this.blockData.a(i, j, k);
}
public void setData(int i, int j, int k, int l) {
+ // CraftBukkit start - Compact storage
+ if (this.blockData == null) {
+ if (this.compactData == l) {
+ return;
+ }
+ this.blockData = expandCompactNibble(this.compactData);
+ }
+ // CraftBukkit end
this.blockData.a(i, j, k, l);
}
@@ -105,71 +175,151 @@ public class ChunkSection {
}
public void setSkyLight(int i, int j, int k, int l) {
+ // CraftBukkit start - Compact storage
+ if (this.skyLight == null) {
+ if (this.compactSky == l) {
+ return;
+ }
+ this.skyLight = expandCompactNibble(this.compactSky);
+ }
+ // CraftBukkit end
this.skyLight.a(i, j, k, l);
}
public int getSkyLight(int i, int j, int k) {
+ // CraftBukkit start - Compact storage
+ if (this.skyLight == null) {
+ return this.compactSky;
+ }
+ // CraftBukkit end
return this.skyLight.a(i, j, k);
}
public void setEmittedLight(int i, int j, int k, int l) {
+ // CraftBukkit start - Compact storage
+ if (this.emittedLight == null) {
+ if (this.compactEmitted == l) {
+ return;
+ }
+ this.emittedLight = expandCompactNibble(this.compactEmitted);
+ }
+ // CraftBukkit end
this.emittedLight.a(i, j, k, l);
}
public int getEmittedLight(int i, int j, int k) {
+ // CraftBukkit start - Compact storage
+ if (this.emittedLight == null) {
+ return this.compactEmitted;
+ }
+ // CraftBukkit end
return this.emittedLight.a(i, j, k);
}
public void recalcBlockCounts() {
// CraftBukkit start - Optimize for speed
- byte[] blkIds = this.blockIds;
int cntNonEmpty = 0;
int cntTicking = 0;
- if (this.extBlockIds == null) { // No extended block IDs? Don't waste time messing with them
- for (int off = 0; off < blkIds.length; off++) {
- int l = blkIds[off] & 0xFF;
- if (l > 0) {
- if (Block.e(l) == null) {
- blkIds[off] = 0;
+
+ if (this.blockIds == null) {
+ int id = this.compactId;
+ if (this.extBlockIds == null) {
+ id |= this.compactExtId << 8;
+ if (id > 0) {
+ Block block = Block.e(id); // Should be getBlockForId
+ if (block == null) {
+ this.compactId = 0;
+ this.compactExtId = 0;
} else {
- ++cntNonEmpty;
- if (Block.e(l).isTicking()) {
- ++cntTicking;
+ cntNonEmpty = 4096;
+ if (block.isTicking()) {
+ cntTicking = 4096;
}
}
}
+ } else {
+ byte[] ext = this.extBlockIds.a;
+ for (int off = 0, off2 = 0; off < 4096;) {
+ byte extid = ext[off2];
+ int l = (id & 0xFF) | ((extid & 0xF) << 8); // Even data
+ if (l > 0) {
+ Block block = Block.e(l); // Should be getBlockForId
+ if (block == null) {
+ this.compactId = 0;
+ ext[off2] &= 0xF0;
+ } else {
+ ++cntNonEmpty;
+ if (block.isTicking()) {
+ ++cntTicking;
+ }
+ }
+ }
+ off++;
+ l = (id & 0xFF) | ((extid & 0xF0) << 4); // Odd data
+ if (l > 0) {
+ Block block = Block.e(l); // Should be getBlockForId
+ if (block == null) {
+ this.compactId = 0;
+ ext[off2] &= 0x0F;
+ } else {
+ ++cntNonEmpty;
+ if (block.isTicking()) {
+ ++cntTicking;
+ }
+ }
+ }
+ off++;
+ off2++;
+ }
}
} else {
- byte[] ext = this.extBlockIds.a;
- for (int off = 0, off2 = 0; off < blkIds.length;) {
- byte extid = ext[off2];
- int l = (blkIds[off] & 0xFF) | ((extid & 0xF) << 8); // Even data
- if (l > 0) {
- if (Block.e(l) == null) {
- blkIds[off] = 0;
- ext[off2] &= 0xF0;
- } else {
- ++cntNonEmpty;
- if (Block.e(l).isTicking()) {
- ++cntTicking;
+ byte[] blkIds = this.blockIds;
+ if (this.extBlockIds == null) { // No extended block IDs? Don't waste time messing with them
+ for (int off = 0; off < blkIds.length; off++) {
+ int l = blkIds[off] & 0xFF;
+ if (l > 0) {
+ if (Block.e(l) == null) {
+ blkIds[off] = 0;
+ } else {
+ ++cntNonEmpty;
+ if (Block.e(l).isTicking()) {
+ ++cntTicking;
+ }
}
}
}
- off++;
- l = (blkIds[off] & 0xFF) | ((extid & 0xF0) << 4); // Odd data
- if (l > 0) {
- if (Block.e(l) == null) {
- blkIds[off] = 0;
- ext[off2] &= 0x0F;
- } else {
- ++cntNonEmpty;
- if (Block.e(l).isTicking()) {
- ++cntTicking;
+ } else {
+ byte[] ext = this.extBlockIds.a;
+ for (int off = 0, off2 = 0; off < blkIds.length;) {
+ byte extid = ext[off2];
+ int l = (blkIds[off] & 0xFF) | ((extid & 0xF) << 8); // Even data
+ if (l > 0) {
+ if (Block.e(l) == null) {
+ blkIds[off] = 0;
+ ext[off2] &= 0xF0;
+ } else {
+ ++cntNonEmpty;
+ if (Block.e(l).isTicking()) {
+ ++cntTicking;
+ }
}
}
+ off++;
+ l = (blkIds[off] & 0xFF) | ((extid & 0xF0) << 4); // Odd data
+ if (l > 0) {
+ if (Block.e(l) == null) {
+ blkIds[off] = 0;
+ ext[off2] &= 0x0F;
+ } else {
+ ++cntNonEmpty;
+ if (Block.e(l).isTicking()) {
+ ++cntTicking;
+ }
+ }
+ }
+ off++;
+ off2++;
}
- off++;
- off2++;
}
}
this.nonEmptyBlockCount = cntNonEmpty;
@@ -198,56 +348,119 @@ public class ChunkSection {
}
public byte[] getIdArray() {
+ // CraftBukkit start - Compact storage
+ if (this.blockIds == null) {
+ byte[] ids = new byte[4096];
+ Arrays.fill(ids, this.compactId);
+ return ids;
+ }
+ // CraftBukkit end
return this.blockIds;
}
public NibbleArray getExtendedIdArray() {
+ // CraftBukkit start - Compact storage
+ if (this.extBlockIds == null && this.compactExtId != 0) {
+ return compactPregen[this.compactExtId];
+ }
+ // CraftBukkit end
return this.extBlockIds;
}
public NibbleArray getDataArray() {
+ // CraftBukkit start - Compact storage
+ if (this.blockData == null) {
+ return compactPregen[this.compactData];
+ }
+ // CraftBukkit end
return this.blockData;
}
public NibbleArray getEmittedLightArray() {
+ // CraftBukkit start - Compact storage
+ if (this.emittedLight == null) {
+ return compactPregen[this.compactEmitted];
+ }
+ // CraftBukkit end
return this.emittedLight;
}
public NibbleArray getSkyLightArray() {
+ // CraftBukkit start - Compact storage
+ if (this.skyLight == null && this.compactSky != -1) {
+ return compactPregen[this.compactSky];
+ }
+ // CraftBukkit end
return this.skyLight;
}
public void setIdArray(byte[] abyte) {
+ // CraftBukkit start - Compact storage
+ if (abyte == null) {
+ this.compactId = 0;
+ this.blockIds = null;
+ return;
+ } else if (canBeCompact(abyte)) {
+ this.compactId = abyte[0];
+ return;
+ }
+ // CraftBukkit end
this.blockIds = this.validateByteArray(abyte); // CraftBukkit - Validate data
}
public void setExtendedIdArray(NibbleArray nibblearray) {
- // CraftBukkit start - Don't hang on to an empty nibble array
- boolean empty = true;
- for (int i = 0; i < nibblearray.a.length; i++) {
- if (nibblearray.a[i] != 0) {
- empty = false;
- break;
- }
- }
-
- if (empty) {
+ // CraftBukkit start - Compact storage
+ if (nibblearray == null) {
+ this.compactExtId = 0;
+ this.extBlockIds = null;
+ return;
+ } else if (canBeCompact(nibblearray.a)) {
+ this.compactExtId = (byte) (nibblearray.a(0, 0, 0) & 0xF);
return;
}
// CraftBukkit end
-
this.extBlockIds = this.validateNibbleArray(nibblearray); // CraftBukkit - Validate data
}
public void setDataArray(NibbleArray nibblearray) {
+ // CraftBukkit start - Compact storage
+ if (nibblearray == null) {
+ this.compactData = 0;
+ this.blockData = null;
+ return;
+ } else if (canBeCompact(nibblearray.a)) {
+ this.compactData = (byte) (nibblearray.a(0, 0, 0) & 0xF);
+ return;
+ }
+ // CraftBukkit end
this.blockData = this.validateNibbleArray(nibblearray); // CraftBukkit - Validate data
}
public void setEmittedLightArray(NibbleArray nibblearray) {
+ // CraftBukkit start - Compact storage
+ if (nibblearray == null) {
+ this.compactEmitted = 0;
+ this.emittedLight = null;
+ return;
+ } else if (canBeCompact(nibblearray.a)) {
+ this.compactEmitted = (byte) (nibblearray.a(0, 0, 0) & 0xF);
+ return;
+ }
+ // CraftBukkit end
this.emittedLight = this.validateNibbleArray(nibblearray); // CraftBukkit - Validate data
}
public void setSkyLightArray(NibbleArray nibblearray) {
+ // CraftBukkit start - Compact storage
+ if (nibblearray == null) {
+ this.compactSky = -1;
+ this.skyLight = null;
+ return;
+ } else if (canBeCompact(nibblearray.a)) {
+ this.compactSky = (byte) (nibblearray.a(0, 0, 0) & 0xF);
+ return;
+ }
+ // CraftBukkit end
this.skyLight = this.validateNibbleArray(nibblearray); // CraftBukkit - Validate data
}
@@ -255,7 +468,7 @@ public class ChunkSection {
private NibbleArray validateNibbleArray(NibbleArray nibbleArray) {
if (nibbleArray != null && nibbleArray.a.length < 2048) {
byte[] newArray = new byte[2048];
- System.arraycopy(nibbleArray.a, 0, newArray, 0, ((nibbleArray.a.length > 2048) ? 2048 : nibbleArray.a.length));
+ System.arraycopy(nibbleArray.a, 0, newArray, 0, nibbleArray.a.length);
nibbleArray = new NibbleArray(newArray, 4);
}