Significantly improve performance of PalettedBlockArray::validate() (#35)

This change introduces a fast path for validation using carry-out vectors, as discussed here: https://devblogs.microsoft.com/oldnewthing/20190301-00/?p=101076

TL;DR: It's possible to detect invalid palette offsets by subtracting the current "word" from a bitfield composed of the max valid palette offset, which is significantly faster than shifting and naively comparing each one.

In addition, we allow the code to chew through the whole loop even if invalid offsets are detected, in the hope that compilers will use SIMD instructions and/or parallelize the loop, which is also substantially faster than breaking out early on a branch condition to throw an exception.

The downside of the fast path is that it cannot report the exact offset an error occurred at, only that an error is present. For this reason, the old, slower code is retained, which allows generating detailed errors if an error is detected.

Note: This does cause a change of behaviour for palettes with padded words (3, 5, and 6 bits per block). The palette is now validated to be zero as a side effect of this change. If non-zero padding is found, the fast path will fail, and fallback to the slow path, which will ignore the error. We may want to explicitly ignore or force padding to be zero.

Author: dktapps

config.w32

@@ -5,7 +5,7 @@ ARG_ENABLE("chunkutils2", "Enable PocketMine ChunkUtils2 extension", "no");
 
 if (PHP_CHUNKUTILS2 != "no") {
 	EXTENSION("chunkutils2", "chunkutils2.cpp", PHP_CHUNKUTILS2_SHARED, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1 /permissive- /I" + configure_module_dirname + " /I" + configure_module_dirname + "/gsl/include /DGSL_THROW_ON_CONTRACT_VIOLATION=1");
-	ADD_FLAG("CFLAGS_CHUNKUTILS2", "/EHsc");
+	ADD_FLAG("CFLAGS_CHUNKUTILS2", "/EHsc /Qvec-report:1");
 	ADD_SOURCES(
 		configure_module_dirname + "/src",
 		"PhpLightArray.cpp PhpPalettedBlockArray.cpp PhpSubChunkConverter.cpp",

lib/PalettedBlockArray.h

@@ -118,14 +118,8 @@ class PalettedBlockArray final : public IPalettedBlockArray<Block> {
 		words[wordIdx] = (words[wordIdx] & ~(BLOCK_MASK << shift)) | (offset << shift);
 	}
 
-	void validate() const {
-		if (MAX_PALETTE_OFFSET == MAX_PALETTE_SIZE && nextPaletteIndex >= MAX_PALETTE_SIZE) {
-			//Every possible offset representable is valid, therefore no validation is required
-			//this is an uncommon case, but more frequent in small palettes, which is a win because small palettes are more
-			//expensive to verify than big ones due to more bitwise operations needed to extract the offsets
-			//for 16 bpb, offsets may point beyond the end of the palette even at full capacity, so they must always be checked
-			return;
-		}
+	void locateAndReportInvalidOffset() const {
+		//Slow path, to allow giving detailed errors when a problem has already been detected by the fast path
 		auto blockCount = 0;
 		for (auto wordIdx = 0; wordIdx < words.size(); wordIdx++) {
 			const auto word = words[wordIdx];
@@ -150,6 +144,54 @@ class PalettedBlockArray final : public IPalettedBlockArray<Block> {
 		}
 	}
 
+#ifdef _MSC_VER
+	//If this function gets inlined, MSVC 16.29 does not want to vectorize it :(
+	__declspec(noinline)
+#endif
+	bool fastValidate() const {
+		Word invalid = 0;
+
+		Word expected = 0;
+		for (unsigned int shift = 0; shift < BLOCKS_PER_WORD * BITS_PER_BLOCK_INT; shift += BITS_PER_BLOCK_INT) {
+			expected |= ((nextPaletteIndex - 1) << shift);
+		}
+
+		//Fast path - use carry-out vectors to detect invalid offsets
+		//This trick is borrowed from https://devblogs.microsoft.com/oldnewthing/20190301-00/?p=101076
+		//We can't detect exactly where the error is with this approach, but we leave that up to the slow code if we detect an error
+		for (auto wordIdx = 0; wordIdx < words.size(); wordIdx++) {
+			const auto word = words[wordIdx];
+
+			if (BITS_PER_BLOCK_INT == 1) {
+				//For 1 bits-per-block, we can only reach this point if the palette isn't full, which means that only offset 0 is set.
+				//This means we can save a few instructions and just check the word directly for non-zero bits.
+				invalid |= word;
+			} else {
+				Word carryVector = (~expected & word) | (~(expected ^ word) & (expected - word));
+				invalid |= carryVector;
+			}
+		}
+
+		return invalid == 0;
+	}
+
+	void validate() const {
+		if (MAX_PALETTE_OFFSET == MAX_PALETTE_SIZE && nextPaletteIndex >= MAX_PALETTE_SIZE) {
+			//Every possible offset representable is valid, therefore no validation is required
+			//this is an uncommon case, but more frequent in small palettes, which is a win because small palettes are more
+			//expensive to verify than big ones due to more bitwise operations needed to extract the offsets
+			//for 16 bpb, offsets may point beyond the end of the palette even at full capacity, so they must always be checked
+			return;
+		}
+
+		if (!fastValidate()) {
+			//If we detected an error, use the old, slow method to locate the (first) source of errors
+			//this allows giving a detailed error message
+			//if the palette is valid, we can avoid this slow path entirely, which is the most likely outcome.
+			locateAndReportInvalidOffset();
+		}
+	}
+
 public:
 
 	PalettedBlockArray(Block block) {