.github/workflows/ci.yml

@@ -7,21 +7,25 @@ on:
 
 jobs:
   build:
-    name: PHP ${{ matrix.php }} (ZTS) Valgrind ${{ matrix.valgrind }}
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     if: "!contains(github.event.head_commit.message, '[ci skip]')"
-
+    name: Tests (PHP ${{ matrix.php }}, Valgrind ${{ matrix.valgrind }}, Debug=${{ matrix.debug }}, ZTS=${{ matrix.zts }})
     strategy:
       fail-fast: false
       matrix:
-        php: ['8.0.27', '8.1.14', '8.2.1']
+        php:
+          - 8.1.26
+          - 8.2.13
+          - 8.3.0
         valgrind: [0, 1]
+        debug: [enable, disable]
+        zts: [enable, disable]
 
     env:
-      CFLAGS: "-march=x86-64"
-      CXXFLAGS: "-march=x86-64"
+      CFLAGS: "-march=x86-64 -ftree-vectorize -fopt-info-vec"
+      CXXFLAGS: "-march=x86-64 -ftree-vectorize -fopt-info-vec"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install Valgrind
         if: matrix.valgrind == '1'
@@ -31,25 +35,41 @@ jobs:
           echo "PHP_BUILD_CONFIGURE_OPTS=--with-valgrind" >> $GITHUB_ENV
 
       - name: Restore PHP build cache
+        uses: actions/cache@v4
         id: php-build-cache
-        uses: actions/cache@v3
         with:
-          path: ${{ github.workspace }}/php
-          key: php-build-debug-${{ matrix.php }}-valgrind-${{ matrix.valgrind }}
+          path: ${{ github.workspace }}/php 
+          key: php-${{ matrix.php }}-debug-${{ matrix.debug }}-valgrind-${{ matrix.valgrind }}-zts-${{ matrix.zts }}
 
-      - name: Clone php-build repository
+      - name: Install PHP build dependencies
         if: steps.php-build-cache.outputs.cache-hit != 'true'
-        uses: actions/checkout@v3
-        with:
-          repository: pmmp/php-build
-          path: php-build
+        run: |
+          sudo apt-get update && sudo apt-get install \
+            re2c
+
+      - name: Get number of CPU cores
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        uses: SimenB/github-actions-cpu-cores@v2
+        id: cpu-cores
+
+      - name: Download PHP
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        working-directory: /tmp
+        run: curl -L https://github.com/php/php-src/archive/refs/tags/php-${{ matrix.php }}.tar.gz | tar -xz
 
       - name: Compile PHP
         if: steps.php-build-cache.outputs.cache-hit != 'true'
+        working-directory: /tmp/php-src-php-${{ matrix.php }}
         run: |
-          cd $GITHUB_WORKSPACE/php-build
-          ./install-dependencies.sh
-          PHP_BUILD_ZTS_ENABLE=on PHP_BUILD_CONFIGURE_OPTS="$PHP_BUILD_CONFIGURE_OPTS --enable-debug" ./bin/php-build ${{ matrix.php }} $GITHUB_WORKSPACE/php
+          ./buildconf --force
+          ./configure \
+            --disable-all \
+            --enable-cli \
+            --${{ matrix.zts }}-zts \
+            --${{ matrix.debug}}-debug \
+            "$PHP_BUILD_CONFIGURE_OPTS" \
+            --prefix="${{ github.workspace }}/php"
+          make -j ${{ steps.cpu-cores.outputs.count }} install
 
       - name: Dump PHP info
         run: $GITHUB_WORKSPACE/php/bin/php -i
@@ -65,9 +85,9 @@ jobs:
 
       - name: Upload test results
         if: failure()
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: test-results-${{ matrix.php }}-valgrind-${{ matrix.valgrind }}
+          name: test-results-${{ matrix.php }}-debug-${{ matrix.debug }}-valgrind-${{ matrix.valgrind }}-zts-${{ matrix.zts }}
           path: |
             ${{ github.workspace }}/tests/*
             !${{ github.workspace }}/tests/*.phpt

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/BlockArrayContainer.h

@@ -108,6 +108,10 @@ class BlockArrayContainer {
 		return blockArray->getPalette();
 	}
 
+	void setPalette(const gsl::span<Block>& newPalette) {
+		blockArray->setPalette(newPalette);
+	}
+
 	unsigned short getMaxPaletteSize() const {
 		return blockArray->getMaxPaletteSize();
 	}

lib/Palette.h

@@ -0,0 +1,162 @@
+#ifndef HAVE_PALETTE_H
+#define HAVE_PALETTE_H
+
+template <size_t MAX_PALETTE_SIZE>
+class PaletteUtils final {
+public:
+	static void checkSize(size_t size) {
+		if (size > MAX_PALETTE_SIZE) {
+			throw std::length_error("palette size should be at most " + std::to_string(MAX_PALETTE_SIZE) + " entries, but received " + std::to_string(size) + " entries");
+		}
+		if (size == 0) {
+			throw std::length_error("palette cannot have a zero size");
+		}
+	}
+};
+
+/*
+* Small palettes use fixed arrays to avoid vector indirections and allocations
+* Performance is more important here because the amount of wasted memory is insignificant
+* regardless of the number of elements in the palette.
+*
+* Lookups are done with a linear search, which is faster than using a hash map for small
+* numbers of elements.
+*/
+template <size_t MAX_PALETTE_SIZE, typename Block>
+class SmallPalette final {
+private:
+	std::array<Block, MAX_PALETTE_SIZE> palette;
+	unsigned short nextPaletteIndex = 0;
+
+	void initFromData(const gsl::span<const Block> paletteEntries) {
+		PaletteUtils<MAX_PALETTE_SIZE>::checkSize(paletteEntries.size());
+
+		memcpy(palette.data(), paletteEntries.data(), paletteEntries.size() * sizeof(Block));
+		nextPaletteIndex = (unsigned short)paletteEntries.size();
+	}
+public:
+	SmallPalette(Block block) {
+		palette[nextPaletteIndex++] = block;
+	}
+
+	SmallPalette(const std::vector<Block>& paletteEntries) {
+		initFromData(paletteEntries);
+	}
+
+	SmallPalette(const gsl::span<const Block>& paletteEntries) {
+		initFromData(paletteEntries);
+	}
+
+	SmallPalette(const SmallPalette& otherArray) {
+		memcpy(palette.data(), otherArray.palette.data(), sizeof(palette));
+		nextPaletteIndex = otherArray.nextPaletteIndex;
+	}
+
+	Block get(unsigned int offset) const {
+		return palette[offset];
+	}
+
+	void set(unsigned int offset, Block val) {
+		palette[offset] = val;
+	}
+
+	const gsl::span<const Block> getPalette() const {
+		return gsl::span<const Block>(palette.data(), nextPaletteIndex);
+	}
+
+	size_t size() const {
+		return nextPaletteIndex;
+	}
+
+	int addOrLookup(Block val) {
+		for (int offset = 0; offset < nextPaletteIndex; ++offset) {
+			if (palette[offset] == val) {
+				return offset;
+			}
+		}
+
+		if (nextPaletteIndex >= MAX_PALETTE_SIZE) {
+			return -1;
+		}
+		int offset = nextPaletteIndex++;
+		palette[offset] = val;
+		return offset;
+	}
+};
+
+/*
+* For large numbers of elements, it's common for a significant fraction of the palette's
+* capacity to be unused, so using a fixed array like SmallPalette would waste a lot of
+* memory. We use a vector instead and pay a small performance penalty.
+*
+* We use the memory we saved to instead keep a hash map of block -> offset for lookups,
+* which significantly improves performance for large palettes. (We only technically save
+* memory as long as the palette is less than half (?) full, but the performance benefits
+* remain in any case.)
+*/
+template <size_t MAX_PALETTE_SIZE, typename Block>
+class LargePalette final {
+private:
+	std::vector<Block> palette;
+	std::unordered_map<Block, unsigned int> blockToOffset;
+
+	void initFromData(const gsl::span<const Block> paletteEntries) {
+		PaletteUtils<MAX_PALETTE_SIZE>::checkSize(paletteEntries.size());
+
+		palette = std::vector<Block>(paletteEntries.begin(), paletteEntries.end());
+		for (unsigned int i = 0; i < palette.size(); ++i) {
+			blockToOffset[palette[i]] = i;
+		}
+	}
+
+public:
+	LargePalette(Block block) {
+		palette.push_back(block);
+		blockToOffset[block] = 0;
+	}
+
+	LargePalette(const std::vector<Block>& paletteEntries) {
+		initFromData(paletteEntries);
+	}
+
+	LargePalette(const gsl::span<const Block>& paletteEntries) {
+		initFromData(paletteEntries);
+	}
+
+	LargePalette(const LargePalette& otherArray) {
+		palette = otherArray.palette;
+		blockToOffset = otherArray.blockToOffset;
+	}
+
+	Block get(unsigned int offset) const {
+		return palette[offset];
+	}
+
+	void set(unsigned int offset, Block val) {
+		palette[offset] = val;
+	}
+
+	const gsl::span<const Block> getPalette() const {
+		return gsl::span<const Block>(palette.data(), palette.size());
+	}
+
+	size_t size() const {
+		return palette.size();
+	}
+
+	int addOrLookup(Block val) {
+		auto it = blockToOffset.find(val);
+		if (it != blockToOffset.end()) {
+			return it->second;
+		}
+
+		if (palette.size() >= MAX_PALETTE_SIZE) {
+			return -1;
+		}
+		int offset = palette.size();
+		palette.push_back(val);
+		blockToOffset[val] = offset;
+		return offset;
+	}
+};
+#endif