From 6364f59ac40ecad5eea3b2691fc8dd8f7582f008 Mon Sep 17 00:00:00 2001 From: Travis Watkins Date: Sat, 21 Jun 2014 11:38:28 -0500 Subject: 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. --- .../java/net/minecraft/server/ChunkSection.java | 331 +++++++++++++++++---- 1 file changed, 272 insertions(+), 59 deletions(-) (limited to 'src/main/java/net/minecraft/server') diff --git a/src/main/java/net/minecraft/server/ChunkSection.java b/src/main/java/net/minecraft/server/ChunkSection.java index a05efa01..787077dc 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); } -- cgit v1.2.3