Add more patches back

2022-06-28 21:25:08 +02:00
parent f0c1c0f5f0
commit 0750e5fe34
32 changed files with 1213 additions and 38 deletions
--- a/patches/server/0071-lithium-chunk.serialization.patch
+++ b/patches/server/0071-lithium-chunk.serialization.patch
@@ -0,0 +1,458 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: jellysquid3 <jellysquid3@users.noreply.github.com>
+Date: Mon, 10 Jan 2022 15:27:58 -0500
+Subject: [PATCH] lithium: chunk.serialization
+
+Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0
+You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings)
+
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..16debe176798f316c122e8e7aef2b50ecb9883a6
+--- /dev/null
+++ b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java
+@@ -0,0 +1,189 @@
+package me.jellysquid.mods.lithium.common.world.chunk;
+
+import com.google.common.collect.ImmutableList;
+import it.unimi.dsi.fastutil.HashCommon;
+import it.unimi.dsi.fastutil.objects.Reference2IntMap;
+import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import net.minecraft.core.IdMap;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.level.chunk.Palette;
+import net.minecraft.world.level.chunk.PaletteResize;
+
+import static it.unimi.dsi.fastutil.Hash.FAST_LOAD_FACTOR;
+
+/**
+ * Generally provides better performance over the vanilla {@link net.minecraft.world.level.chunk.HashMapPalette} when calling
+ * {@link LithiumHashPalette#idFor(Object)} through using a faster backing map and reducing pointer chasing.
+ */
+public class LithiumHashPalette<T> implements Palette<T> {
+    private static final int ABSENT_VALUE = -1;
+
+    private final IdMap<T> idList;
+    private final PaletteResize<T> resizeHandler;
+    private final int indexBits;
+
+    private final Reference2IntMap<T> table;
+    private T[] entries;
+    private int size = 0;
+
+    public LithiumHashPalette(IdMap<T> idList, PaletteResize<T> resizeHandler, int indexBits, T[] entries, Reference2IntMap<T> table, int size) {
+        this.idList = idList;
+        this.resizeHandler = resizeHandler;
+        this.indexBits = indexBits;
+        this.entries = entries;
+        this.table = table;
+        this.size = size;
+    }
+
+    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler, List<T> list) {
+        this(idList, bits, resizeHandler);
+
+        for (T t : list) {
+            this.addEntry(t);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler) {
+        this.idList = idList;
+        this.indexBits = bits;
+        this.resizeHandler = resizeHandler;
+
+        int capacity = 1 << bits;
+
+        this.entries = (T[]) new Object[capacity];
+        this.table = new Reference2IntOpenHashMap<>(capacity, FAST_LOAD_FACTOR);
+        this.table.defaultReturnValue(ABSENT_VALUE);
+    }
+
+    @Override
+    public int idFor(T obj) {
+        int id = this.table.getInt(obj);
+
+        if (id == ABSENT_VALUE) {
+            id = this.computeEntry(obj);
+        }
+
+        return id;
+    }
+
+    @Override
+    public boolean maybeHas(Predicate<T> predicate) {
+        for (int i = 0; i < this.size; ++i) {
+            if (predicate.test(this.entries[i])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private int computeEntry(T obj) {
+        int id = this.addEntry(obj);
+
+        if (id >= 1 << this.indexBits) {
+            if (this.resizeHandler == null) {
+                throw new IllegalStateException("Cannot grow");
+            } else {
+                id = this.resizeHandler.onResize(this.indexBits + 1, obj);
+            }
+        }
+
+        return id;
+    }
+
+    private int addEntry(T obj) {
+        int nextId = this.size;
+
+        if (nextId >= this.entries.length) {
+            this.resize(this.size);
+        }
+
+        this.table.put(obj, nextId);
+        this.entries[nextId] = obj;
+
+        this.size++;
+
+        return nextId;
+    }
+
+    private void resize(int neededCapacity) {
+        this.entries = Arrays.copyOf(this.entries, HashCommon.nextPowerOfTwo(neededCapacity + 1));
+    }
+
+    @Override
+    public T valueFor(int id) {
+        T[] entries = this.entries;
+
+        if (id >= 0 && id < entries.length) {
+            return entries[id];
+        }
+
+        return null;
+    }
+
+    @Override
+    public void read(FriendlyByteBuf buf) {
+        this.clear();
+
+        int entryCount = buf.readVarInt();
+
+        for (int i = 0; i < entryCount; ++i) {
+            this.addEntry(this.idList.byId(buf.readVarInt()));
+        }
+    }
+
+    @Override
+    public void write(FriendlyByteBuf buf) {
+        int size = this.size;
+        buf.writeVarInt(size);
+
+        for (int i = 0; i < size; ++i) {
+            buf.writeVarInt(this.idList.getId(this.valueFor(i)));
+        }
+    }
+
+    @Override
+    public int getSerializedSize() {
+        int size = FriendlyByteBuf.getVarIntSize(this.size);
+
+        for (int i = 0; i < this.size; ++i) {
+            size += FriendlyByteBuf.getVarIntSize(this.idList.getId(this.valueFor(i)));
+        }
+
+        return size;
+    }
+
+    @Override
+    public int getSize() {
+        return this.size;
+    }
+
+    @Override
+    public Palette<T> copy() {
+        return new LithiumHashPalette<>(this.idList, this.resizeHandler, this.indexBits, this.entries.clone(), new Reference2IntOpenHashMap<>(this.table), this.size);
+    }
+
+    private void clear() {
+        Arrays.fill(this.entries, null);
+        this.table.clear();
+        this.size = 0;
+    }
+
+    public List<T> getElements() {
+        ImmutableList.Builder<T> builder = new ImmutableList.Builder<>();
+        for (T entry : this.entries) {
+            if (entry != null) {
+                builder.add(entry);
+            }
+        }
+        return builder.build();
+    }
+
+    public static <A> Palette<A> create(int bits, IdMap<A> idList, PaletteResize<A> listener, List<A> list) {
+        return new LithiumHashPalette<>(idList, bits, listener, list);
+    }
+}
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/util/BitStorage.java b/src/main/java/net/minecraft/util/BitStorage.java
+index 106610ccc74b70b557b01c61262d56c4f1147acf..fc986f02290fbe20246022072944980f35dd200c 100644
+--- a/src/main/java/net/minecraft/util/BitStorage.java
+++ b/src/main/java/net/minecraft/util/BitStorage.java
+@@ -1,6 +1,7 @@
+ package net.minecraft.util;
+ 
+ import java.util.function.IntConsumer;
+import net.minecraft.world.level.chunk.Palette; // JettPack
+ 
+ public interface BitStorage {
+     int getAndSet(int index, int value);
+@@ -31,4 +32,6 @@ public interface BitStorage {
+ 
+     }
+     // Paper end
+
+    <T> void compact(Palette<T> srcPalette, Palette<T> dstPalette, short[] out); // JettPack - lithium: chunk.serialization
+ }
+diff --git a/src/main/java/net/minecraft/util/SimpleBitStorage.java b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+index 36e33923bf48e56c743ed043bcbc66bc32f0422f..0272dee738e86e066108f5cc3729136335d8197e 100644
+--- a/src/main/java/net/minecraft/util/SimpleBitStorage.java
+++ b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+@@ -2,6 +2,7 @@ package net.minecraft.util;
+ 
+ import java.util.function.IntConsumer;
+ import javax.annotation.Nullable;
+import net.minecraft.world.level.chunk.Palette; // JettPack
+ import org.apache.commons.lang3.Validate;
+ 
+ public class SimpleBitStorage implements BitStorage {
+@@ -201,4 +202,44 @@ public class SimpleBitStorage implements BitStorage {
+             super(message);
+         }
+     }
+
+    // JettPack start - lithium: chunk.serialization
+    @Override
+    public <T> void compact(Palette<T> srcPalette, Palette<T> dstPalette, short[] out) {
+        if (this.size >= Short.MAX_VALUE) {
+            throw new IllegalStateException("Array too large");
+        }
+
+        if (this.size != out.length) {
+            throw new IllegalStateException("Array size mismatch");
+        }
+
+        short[] mappings = new short[(int) (this.mask + 1)];
+
+        int idx = 0;
+
+        for (long word : this.data) {
+            long bits = word;
+
+            for (int elementIdx = 0; elementIdx < this.valuesPerLong; ++elementIdx) {
+                int value = (int) (bits & this.mask);
+                int remappedId = mappings[value];
+
+                if (remappedId == 0) {
+                    remappedId = dstPalette.idFor(srcPalette.valueFor(value)) + 1;
+                    mappings[value] = (short) remappedId;
+                }
+
+                out[idx] = (short) (remappedId - 1);
+                bits >>= this.bits;
+
+                ++idx;
+
+                if (idx >= this.size) {
+                    return;
+                }
+            }
+        }
+    }
+    // JettPack end
+ }
+diff --git a/src/main/java/net/minecraft/util/ZeroBitStorage.java b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+index 97c744508cc535418eba65fa722859c81c22d647..a2ea0a2864b9c4f847f1a14ffc0900e67c18f9ee 100644
+--- a/src/main/java/net/minecraft/util/ZeroBitStorage.java
+++ b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+@@ -2,6 +2,7 @@ package net.minecraft.util;
+ 
+ import java.util.Arrays;
+ import java.util.function.IntConsumer;
+import net.minecraft.world.level.chunk.Palette; // JettPack
+ import org.apache.commons.lang3.Validate;
+ 
+ public class ZeroBitStorage implements BitStorage {
+@@ -72,4 +73,6 @@ public class ZeroBitStorage implements BitStorage {
+     public BitStorage copy() {
+         return this;
+     }
+
+    @Override public <T> void compact(Palette<T> srcPalette, Palette<T> dstPalette, short[] out) {} // JettPack
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
+index acae3eb30e0689048937f479dc3070f0688abdad..9c2b79655f2c63a208c7087d5d897db0fb23f697 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
+++ b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
+@@ -1,5 +1,5 @@
+ package net.minecraft.world.level.chunk;
+ 
+-interface PaletteResize<T> {
+public interface PaletteResize<T> { // JettPack - make public
+     int onResize(int newBits, T object);
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+index 08e1309e618377d170c446a1568c21b7bf4e5683..0b4f66d0ef963d6f47b20469b7a1e3f6c3da7c83 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -22,8 +22,23 @@ import net.minecraft.util.Mth;
+ import net.minecraft.util.SimpleBitStorage;
+ import net.minecraft.util.ThreadingDetector;
+ import net.minecraft.util.ZeroBitStorage;
+import me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette; // JettPack
+ 
+ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainerRO<T> {
+    // JettPack start - lithium: chunk.serialization
+    private static final ThreadLocal<short[]> CACHED_ARRAY_4096 = ThreadLocal.withInitial(() -> new short[4096]);
+    private static final ThreadLocal<short[]> CACHED_ARRAY_64 = ThreadLocal.withInitial(() -> new short[64]);
+    private Optional<LongStream> asOptional(long[] data) {
+        return Optional.of(Arrays.stream(data));
+    }
+    private short[] getOrCreate(int size) {
+        return switch (size) {
+            case 64 -> CACHED_ARRAY_64.get();
+            case 4096 -> CACHED_ARRAY_4096.get();
+            default -> new short[size];
+        };
+    }
+    // JettPack end
+     private static final int MIN_PALETTE_BITS = 0;
+     private final PaletteResize<T> dummyPaletteResize = (newSize, added) -> {
+         return 0;
+@@ -298,30 +313,54 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     public synchronized PalettedContainerRO.PackedData<T> pack(IdMap<T> idMap, PalettedContainer.Strategy strategy) { // Paper - synchronize
+         this.acquire();
+ 
+-        PalettedContainerRO.PackedData var12;
+        // JettPack start - lithium: chunk.serialization
+        Optional<LongStream> data = Optional.empty();
+        List<T> elements = null;
+         try {
+-            HashMapPalette<T> hashMapPalette = new HashMapPalette<>(idMap, this.data.storage.getBits(), this.dummyPaletteResize);
+-            int i = strategy.size();
+-            int[] is = new int[i];
+-            this.data.storage.unpack(is);
+-            swapPalette(is, (ix) -> {
+-                return hashMapPalette.idFor(this.data.palette.valueFor(ix));
+-            });
+-            int j = strategy.calculateBitsForSerialization(idMap, hashMapPalette.getSize());
+-            Optional<LongStream> optional;
+-            if (j != 0) {
+-                SimpleBitStorage simpleBitStorage = new SimpleBitStorage(j, i, is);
+-                optional = Optional.of(Arrays.stream(simpleBitStorage.getRaw()));
+-            } else {
+-                optional = Optional.empty();
+            // The palette that will be serialized
+            LithiumHashPalette<T> hashPalette = null;
+
+            final Palette<T> palette = this.data.palette();
+            final BitStorage storage = this.data.storage();
+            if (storage instanceof ZeroBitStorage || palette.getSize() == 1) {
+                // If the palette only contains one entry, don't attempt to repack it.
+                elements = List.of(palette.valueFor(0));
+            } else if (palette instanceof LithiumHashPalette<T> lithiumHashPalette) {
+                hashPalette = lithiumHashPalette;
+             }
+ 
+-            var12 = new PalettedContainerRO.PackedData<>(hashMapPalette.getEntries(), optional);
+            if (elements == null) {
+                LithiumHashPalette<T> compactedPalette = new LithiumHashPalette<>(idMap, storage.getBits(), this.dummyPaletteResize);
+                short[] array = this.getOrCreate(strategy.size());
+
+                storage.compact(this.data.palette(), compactedPalette, array);
+
+                // If the palette didn't change during compaction, do a simple copy of the data array
+                if (hashPalette != null && hashPalette.getSize() == compactedPalette.getSize() && storage.getBits() == strategy.calculateBitsForSerialization(idMap, hashPalette.getSize())) { // paletteSize can de-sync from palette - see https://github.com/CaffeineMC/lithium-fabric/issues/279
+                    data = this.asOptional(storage.getRaw().clone());
+                    elements = hashPalette.getElements();
+                } else {
+                    int bits = strategy.calculateBitsForSerialization(idMap, compactedPalette.getSize());
+                    if (bits != 0) {
+                        // Re-pack the integer array as the palette has changed size
+                        SimpleBitStorage copy = new SimpleBitStorage(bits, array.length);
+                        for (int i = 0; i < array.length; ++i) {
+                            copy.set(i, array[i]);
+                        }
+
+                        // We don't need to clone the data array as we are the sole owner of it
+                        data = this.asOptional(copy.getRaw());
+                    }
+
+                    elements = compactedPalette.getElements();
+                }
+            }
+         } finally {
+             this.release();
+         }
+ 
+-        return var12;
+        return new PalettedContainerRO.PackedData<>(elements, data);
+        // JettPack end
+     }
+ 
+     private static <T> void swapPalette(int[] is, IntUnaryOperator intUnaryOperator) {
+@@ -361,17 +400,37 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+ 
+     @Override
+     public void count(PalettedContainer.CountConsumer<T> counter) {
+-        if (this.data.palette.getSize() == 1) {
+-            counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
+-        } else {
+-            Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap();
+-            this.data.storage.getAll((key) -> {
+-                int2IntOpenHashMap.addTo(key, 1);
+-            });
+-            int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> {
+-                counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue());
+-            });
+        // JettPack start - lithium: chunk.serialization
+        int len = this.data.palette().getSize();
+
+        // Do not allocate huge arrays if we're using a large palette
+        if (len > 4096) {
+            // VanillaCopy
+            if (this.data.palette.getSize() == 1) {
+                counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
+            } else {
+                Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap();
+                this.data.storage.getAll((key) -> {
+                    int2IntOpenHashMap.addTo(key, 1);
+                });
+                int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> {
+                    counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue());
+                });
+            }
+        }
+
+        short[] counts = new short[len];
+
+        this.data.storage().getAll(i -> counts[i]++);
+
+        for (int i = 0; i < counts.length; i++) {
+            T obj = this.data.palette().valueFor(i);
+
+            if (obj != null) {
+                counter.accept(obj, counts[i]);
+            }
+         }
+        // JettPack end
+     }
+ 
+     static record Configuration<T>(Palette.Factory factory, int bits) {
--- a/patches/server/0072-Configurable-criterion-triggers.patch
+++ b/patches/server/0072-Configurable-criterion-triggers.patch
--- a/patches/server/0073-Set-item-stuck-sleep-to-15-ticks.patch
+++ b/patches/server/0073-Set-item-stuck-sleep-to-15-ticks.patch
--- a/patches/server/0074-Smarter-statistics-ticking.patch
+++ b/patches/server/0074-Smarter-statistics-ticking.patch
--- a/patches/server/0075-lithium-ai.nearby_entity_tracking-and-ai.nearby_enti.patch
+++ b/patches/server/0075-lithium-ai.nearby_entity_tracking-and-ai.nearby_enti.patch
--- a/patches/server/0076-some-entity-micro-opts.patch
+++ b/patches/server/0076-some-entity-micro-opts.patch
--- a/patches/server/0077-Dont-eat-blocks-in-non-ticking-chunks.patch
+++ b/patches/server/0077-Dont-eat-blocks-in-non-ticking-chunks.patch
--- a/patches/server/0078-Fast-speed-check.patch
+++ b/patches/server/0078-Fast-speed-check.patch
--- a/patches/server/0079-lithium-cache-iterate-outwards.patch
+++ b/patches/server/0079-lithium-cache-iterate-outwards.patch
@@ -0,0 +1,175 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: 2No2Name <2No2Name@web.de>
+Date: Thu, 13 Jan 2022 15:38:29 -0500
+Subject: [PATCH] lithium: cache iterate outwards
+
+Original code by the PR below, licensed under GNU Lesser General Public License v3.0
+You can find the original code on https://github.com/CaffeineMC/lithium-fabric/pull/123 (Yarn mappings)
+
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/IterateOutwardsCache.java b/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/IterateOutwardsCache.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5d3aa309d3fdaab9e0fea2dfb91a080a3ac1193
+--- /dev/null
+++ b/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/IterateOutwardsCache.java
+@@ -0,0 +1,71 @@
+package me.jellysquid.mods.lithium.common.cached_blockpos_iteration;
+
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import it.unimi.dsi.fastutil.longs.LongList;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import net.minecraft.core.BlockPos;
+
+/**
+ * @author 2No2Name, original implemenation by SuperCoder7979 and Gegy1000
+ */
+public class IterateOutwardsCache {
+    //POS_ZERO must not be replaced with BlockPos.ORIGIN, otherwise iterateOutwards at BlockPos.ORIGIN will not use the cache
+    public static final BlockPos POS_ZERO = new BlockPos(0,0,0);
+
+
+    private final ConcurrentHashMap<Long, LongArrayList> table;
+    private final int capacity;
+    private final Random random;
+
+    public IterateOutwardsCache(int capacity) {
+        this.capacity = capacity;
+        this.table = new ConcurrentHashMap<>(31);
+        this.random = new Random();
+    }
+
+    private void fillPositionsWithIterateOutwards(LongList entry, int xRange, int yRange, int zRange) {
+        // Add all positions to the cached list
+        for (BlockPos pos : BlockPos.withinManhattan(POS_ZERO, xRange, yRange, zRange)) {
+            entry.add(pos.asLong());
+        }
+    }
+
+    public LongList getOrCompute(int xRange, int yRange, int zRange) {
+        long key = BlockPos.asLong(xRange, yRange, zRange);
+
+        LongArrayList entry = this.table.get(key);
+        if (entry != null) {
+            return entry;
+        }
+
+        // Cache miss: compute and store
+        entry = new LongArrayList(128);
+
+        this.fillPositionsWithIterateOutwards(entry, xRange, yRange, zRange);
+
+        //decrease the array size, as of now it won't be modified anymore anyways
+        entry.trim();
+
+        //this might overwrite an entry as the same entry could have been computed and added during this thread's computation
+        //we do not use computeIfAbsent, as it can delay other threads for too long
+        Object previousEntry = this.table.put(key, entry);
+
+
+        if (previousEntry == null && this.table.size() > this.capacity) {
+            //prevent a memory leak by randomly removing about 1/8th of the elements when the exceed the desired capacity is exceeded
+            final Iterator<Long> iterator = this.table.keySet().iterator();
+            //prevent an unlikely infinite loop caused by another thread filling the table concurrently using counting
+            for (int i = -this.capacity; iterator.hasNext() && i < 5; i++) {
+                Long key2 = iterator.next();
+                //random is not threadsafe, but it doesn't matter here, because we don't need quality random numbers
+                if (this.random.nextInt(8) == 0 && key2 != key) {
+                    iterator.remove();
+                }
+            }
+        }
+
+        return entry;
+    }
+}
+\ No newline at end of file
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/LongList2BlockPosMutableIterable.java b/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/LongList2BlockPosMutableIterable.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..493661ff3ac7247b68b7b02784b09b0eaf88fc52
+--- /dev/null
+++ b/src/main/java/me/jellysquid/mods/lithium/common/cached_blockpos_iteration/LongList2BlockPosMutableIterable.java
+@@ -0,0 +1,46 @@
+package me.jellysquid.mods.lithium.common.cached_blockpos_iteration;
+
+import it.unimi.dsi.fastutil.longs.LongIterator;
+import it.unimi.dsi.fastutil.longs.LongList;
+import java.util.Iterator;
+import net.minecraft.core.BlockPos;
+
+/**
+ * @author 2No2Name
+ */
+public class LongList2BlockPosMutableIterable implements Iterable<BlockPos> {
+
+    private final LongList positions;
+    private final int xOffset, yOffset, zOffset;
+
+    public LongList2BlockPosMutableIterable(BlockPos offset, LongList posList) {
+        this.xOffset = offset.getX();
+        this.yOffset = offset.getY();
+        this.zOffset = offset.getZ();
+        this.positions = posList;
+    }
+
+    @Override
+    public Iterator<BlockPos> iterator() {
+        return new Iterator<BlockPos>() {
+
+            private final LongIterator it = LongList2BlockPosMutableIterable.this.positions.iterator();
+            private final BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+
+            @Override
+            public boolean hasNext() {
+                return it.hasNext();
+            }
+
+            @Override
+            public net.minecraft.core.BlockPos next() {
+                long nextPos = this.it.nextLong();
+                return this.pos.set(
+                        LongList2BlockPosMutableIterable.this.xOffset + BlockPos.getX(nextPos),
+                        LongList2BlockPosMutableIterable.this.yOffset + BlockPos.getY(nextPos),
+                        LongList2BlockPosMutableIterable.this.zOffset + BlockPos.getZ(nextPos));
+            }
+        };
+    }
+
+}
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
+index 153451ecd5b3c8e8ecb2d5ec91ccd582d4300899..4487752469f9ab95e9d2aeb76a9627dc02095d76 100644
+--- a/src/main/java/net/minecraft/core/BlockPos.java
+++ b/src/main/java/net/minecraft/core/BlockPos.java
+@@ -18,6 +18,12 @@ import net.minecraft.world.phys.AABB;
+ import net.minecraft.world.phys.Vec3;
+ import org.apache.commons.lang3.Validate;
+ import org.slf4j.Logger;
+// JettPack start
+import it.unimi.dsi.fastutil.longs.LongList;
+import me.jellysquid.mods.lithium.common.cached_blockpos_iteration.IterateOutwardsCache;
+import me.jellysquid.mods.lithium.common.cached_blockpos_iteration.LongList2BlockPosMutableIterable;
+import static me.jellysquid.mods.lithium.common.cached_blockpos_iteration.IterateOutwardsCache.POS_ZERO;
+// JettPack end
+ 
+ @Immutable
+ public class BlockPos extends Vec3i {
+@@ -284,7 +290,18 @@ public class BlockPos extends Vec3i {
+         };
+     }
+ 
+    // JettPack start - lithium: cached iterate outwards
+    private static final IterateOutwardsCache ITERATE_OUTWARDS_CACHE = new IterateOutwardsCache(50);
+    private static final LongList HOGLIN_PIGLIN_CACHE = ITERATE_OUTWARDS_CACHE.getOrCompute(8, 4, 8);
+    // JettPack end
+
+     public static Iterable<BlockPos> withinManhattan(BlockPos center, int rangeX, int rangeY, int rangeZ) {
+        // JettPack start - lithium: cached iterate outwards
+        if (center != POS_ZERO) {
+            final LongList positions = rangeX == 8 && rangeY == 4 && rangeZ == 8 ? HOGLIN_PIGLIN_CACHE : ITERATE_OUTWARDS_CACHE.getOrCompute(rangeX, rangeY, rangeZ);
+            return new LongList2BlockPosMutableIterable(center, positions);
+        }
+        // JettPack end
+         int i = rangeX + rangeY + rangeZ;
+         // Paper start - rename variables to fix conflict with anonymous class (remap fix)
+         int centerX = center.getX();
--- a/patches/server/0080-lithium-ai.raid.patch
+++ b/patches/server/0080-lithium-ai.raid.patch
@@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: jellysquid3 <jellysquid3@users.noreply.github.com>
+Date: Tue, 18 Jan 2022 10:37:18 -0500
+Subject: [PATCH] lithium: ai.raid
+
+Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0
+You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings)
+
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raid.java b/src/main/java/net/minecraft/world/entity/raid/Raid.java
+index 6a0a1731fd6804eb69d3641213712d31bce085b2..5f4bb589474ce7d4f214e32ab0bc4b9cb71638d0 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raid.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raid.java
+@@ -269,7 +269,16 @@ public class Raid {
+         this.status = Raid.RaidStatus.STOPPED;
+     }
+ 
+    private boolean isBarDirty; // JettPack
+     public void tick() {
+        // JettPack start - lithium: ai.raid
+        if (this.isBarDirty) {
+            this.raidEvent.setProgress(Mth.clamp(this.getHealthOfLivingRaiders() / this.totalHealth, 0.0F, 1.0F));
+
+            this.isBarDirty = false;
+        }
+        // JettPack end
+
+         if (!this.isStopped()) {
+             if (this.status == Raid.RaidStatus.ONGOING) {
+                 boolean flag = this.active;
+@@ -626,7 +635,7 @@ public class Raid {
+     }
+ 
+     public void updateBossbar() {
+-        this.raidEvent.setProgress(Mth.clamp(this.getHealthOfLivingRaiders() / this.totalHealth, 0.0F, 1.0F));
+        this.isBarDirty = true; // JettPack - lithium: ai.raid
+     }
+ 
+     public float getHealthOfLivingRaiders() {
+diff --git a/src/main/java/net/minecraft/world/entity/raid/Raider.java b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+index 4bb9730b6a42702e91467f980b9f045585039db3..7ba9c7f995c2bacc8f9a86a78747ea30f45eb59a 100644
+--- a/src/main/java/net/minecraft/world/entity/raid/Raider.java
+++ b/src/main/java/net/minecraft/world/entity/raid/Raider.java
+@@ -46,8 +46,9 @@ import net.minecraft.world.phys.Vec3;
+ public abstract class Raider extends PatrollingMonster {
+ 
+     protected static final EntityDataAccessor<Boolean> IS_CELEBRATING = SynchedEntityData.defineId(Raider.class, EntityDataSerializers.BOOLEAN);
+    public static final ItemStack CACHED_OMINOUS_BANNER = Raid.getLeaderBannerInstance(); // JettPack - lithium: ai.raid
+     static final Predicate<ItemEntity> ALLOWED_ITEMS = (entityitem) -> {
+-        return !entityitem.hasPickUpDelay() && entityitem.isAlive() && ItemStack.matches(entityitem.getItem(), Raid.getLeaderBannerInstance());
+        return !entityitem.hasPickUpDelay() && entityitem.isAlive() && ItemStack.matches(entityitem.getItem(), CACHED_OMINOUS_BANNER); // JettPack - lithium: ai.raid
+     };
+     @Nullable
+     protected Raid raid;
+@@ -149,7 +150,7 @@ public abstract class Raider extends PatrollingMonster {
+                     }
+                 }
+ 
+-                if (!itemstack.isEmpty() && ItemStack.matches(itemstack, Raid.getLeaderBannerInstance()) && entityhuman != null) {
+                if (!itemstack.isEmpty() && ItemStack.matches(itemstack, CACHED_OMINOUS_BANNER) && entityhuman != null) { // JettPack - lithium: ai.raid
+                     MobEffectInstance mobeffect = entityhuman.getEffect(MobEffects.BAD_OMEN);
+                     byte b0 = 1;
+                     int i;
+@@ -304,6 +305,7 @@ public abstract class Raider extends PatrollingMonster {
+     public class ObtainRaidLeaderBannerGoal<T extends Raider> extends Goal {
+ 
+         private final T mob;
+        private static final ItemStack CACHED_OMINOUS_BANNER = Raid.getLeaderBannerInstance(); // JettPack
+ 
+         public ObtainRaidLeaderBannerGoal(T entityraider) { // CraftBukkit - decompile error
+             this.mob = entityraider;
+@@ -315,7 +317,7 @@ public abstract class Raider extends PatrollingMonster {
+             if (!this.mob.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING) || !this.mob.canPickUpLoot()) return false; // Paper - respect game and entity rules for picking up items
+             Raid raid = this.mob.getCurrentRaid();
+ 
+-            if (this.mob.hasActiveRaid() && !this.mob.getCurrentRaid().isOver() && this.mob.canBeLeader() && !ItemStack.matches(this.mob.getItemBySlot(EquipmentSlot.HEAD), Raid.getLeaderBannerInstance())) {
+            if (this.mob.hasActiveRaid() && !this.mob.getCurrentRaid().isOver() && this.mob.canBeLeader() && !ItemStack.matches(this.mob.getItemBySlot(EquipmentSlot.HEAD), CACHED_OMINOUS_BANNER)) { // JettPack - lithium: ai.raid
+                 Raider entityraider = raid.getLeader(this.mob.getWave());
+ 
+                 if (entityraider == null || !entityraider.isAlive()) {
--- a/patches/server/0080-lithium-gen.cached_generator_settings.patch
+++ b/patches/server/0080-lithium-gen.cached_generator_settings.patch
@@ -1,38 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: SuperCoder7979 <25208576+SuperCoder7979@users.noreply.github.com>
-Date: Fri, 22 Jan 2021 16:38:19 -0500
-Subject: [PATCH] lithium: gen.cached_generator_settings
-
-Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0
-You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings)
-
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-index df1db87d2dd5076fccea6a1ac9271a9d786729bb..47e611d674865f4c6e36032df61bb9bf284f5286 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-@@ -67,6 +67,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
-     public final Registry<NormalNoise.NoiseParameters> noises;
-     public final Holder<NoiseGeneratorSettings> settings;
-     private final Aquifer.FluidPicker globalFluidPicker;
-+    private final int cachedSeaLevel; // Mirai - lithium: gen.cached_generator_settings
- 
-     public NoiseBasedChunkGenerator(Registry<StructureSet> structureSetRegistry, Registry<NormalNoise.NoiseParameters> noiseRegistry, BiomeSource populationSource, Holder<NoiseGeneratorSettings> holder) {
-         super(structureSetRegistry, Optional.empty(), populationSource);
-@@ -83,6 +84,8 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
-         this.globalFluidPicker = (j, k, l) -> {
-             return k < Math.min(-54, i) ? aquifer_b : aquifer_b1;
-         };
-+
-+        this.cachedSeaLevel = ((NoiseGeneratorSettings) this.settings.value()).seaLevel(); // Mirai - lithium: gen.cached_generator_settings
-     }
- 
-     @Override
-@@ -400,7 +403,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
- 
-     @Override
-     public int getSeaLevel() {
-        return ((NoiseGeneratorSettings) this.settings.value()).seaLevel();
-+        return this.cachedSeaLevel; // Mirai - lithium: gen.cached_generator_settings
-     }
- 
-     @Override
--- a/patches/server/0081-lithium-block.moving_block_shapes.patch
+++ b/patches/server/0081-lithium-block.moving_block_shapes.patch
--- a/patches/server/0082-lithium-shapes.blockstate_cache.patch
+++ b/patches/server/0082-lithium-shapes.blockstate_cache.patch
--- a/patches/server/0083-lithium-gen.patch
+++ b/patches/server/0083-lithium-gen.patch
@@ -0,0 +1,243 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SuperCoder7979 <25208576+SuperCoder7979@users.noreply.github.com>
+Date: Fri, 22 Jan 2021 16:38:19 -0500
+Subject: [PATCH] lithium: gen
+
+Original code by CaffeineMC, licensed under GNU Lesser General Public License v3.0
+You can find the original code on https://github.com/CaffeineMC/lithium-fabric (Yarn mappings)
+
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c99eff34c1be07508c88fe9525c3ae1a087fdef7
+--- /dev/null
+++ b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java
+@@ -0,0 +1,92 @@
+package me.jellysquid.mods.lithium.common.util;
+
+import net.minecraft.core.SectionPos;
+import net.minecraft.world.level.LevelHeightAccessor;
+
+public class Pos {
+
+    public static class BlockCoord {
+        public static int getYSize(LevelHeightAccessor view) {
+            return view.getHeight();
+        }
+        public static int getMinY(LevelHeightAccessor view) {
+            return view.getMinBuildHeight();
+        }
+        public static int getMaxYInclusive(LevelHeightAccessor view) {
+            return view.getMaxBuildHeight() - 1;
+        }
+        public static int getMaxYExclusive(LevelHeightAccessor view) {
+            return view.getMaxBuildHeight();
+        }
+
+        public static int getMaxInSectionCoord(int sectionCoord) {
+            return 15 + getMinInSectionCoord(sectionCoord);
+        }
+
+        public static int getMaxYInSectionIndex(LevelHeightAccessor view, int sectionIndex){
+            return getMaxInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex));
+        }
+
+        public static int getMinInSectionCoord(int sectionCoord) {
+            return SectionPos.sectionToBlockCoord(sectionCoord);
+        }
+
+        public static int getMinYInSectionIndex(LevelHeightAccessor view, int sectionIndex) {
+            return getMinInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex));
+        }
+    }
+
+    public static class ChunkCoord {
+        public static int fromBlockCoord(int blockCoord) {
+            return SectionPos.blockToSectionCoord(blockCoord);
+        }
+
+        public static int fromBlockSize(int i) {
+            return i >> 4; //same method as fromBlockCoord, just be clear about coord/size semantic difference
+        }
+    }
+
+    public static class SectionYCoord {
+        public static int getNumYSections(LevelHeightAccessor view) {
+            return view.getSectionsCount();
+        }
+        public static int getMinYSection(LevelHeightAccessor view) {
+            return view.getMinSection();
+        }
+        public static int getMaxYSectionInclusive(LevelHeightAccessor view) {
+            return view.getMaxSection() - 1;
+        }
+        public static int getMaxYSectionExclusive(LevelHeightAccessor view) {
+            return view.getMaxSection();
+        }
+
+        public static int fromSectionIndex(LevelHeightAccessor view, int sectionCoord) {
+            return sectionCoord + SectionYCoord.getMinYSection(view);
+        }
+        public static int fromBlockCoord(int blockCoord) {
+            return SectionPos.blockToSectionCoord(blockCoord);
+        }
+    }
+
+    public static class SectionYIndex {
+        public static int getNumYSections(LevelHeightAccessor view) {
+            return view.getSectionsCount();
+        }
+        public static int getMinYSectionIndex(LevelHeightAccessor view) {
+            return 0;
+        }
+        public static int getMaxYSectionIndexInclusive(LevelHeightAccessor view) {
+            return view.getSectionsCount() - 1;
+        }
+        public static int getMaxYSectionIndexExclusive(LevelHeightAccessor view) {
+            return view.getSectionsCount();
+        }
+
+        public static int fromSectionCoord(LevelHeightAccessor view, int sectionCoord) {
+            return sectionCoord - SectionYCoord.getMinYSection(view);
+        }
+        public static int fromBlockCoord(LevelHeightAccessor view, int blockCoord) {
+            return fromSectionCoord(view, SectionPos.blockToSectionCoord(blockCoord));
+        }
+    }
+}
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+index d37ba3fec0e4011629a5fbc88d377d52267ad395..4967605f46a58ad9888c6a997f950f50d1bd5d1e 100644
+--- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+@@ -53,6 +53,7 @@ import net.minecraft.world.phys.Vec3;
+ import net.minecraft.world.ticks.LevelTickAccess;
+ import net.minecraft.world.ticks.WorldGenTickAccess;
+ import org.slf4j.Logger;
+import me.jellysquid.mods.lithium.common.util.Pos; // Mirai - lithium: gen
+ 
+ public class WorldGenRegion implements WorldGenLevel {
+ 
+@@ -81,6 +82,8 @@ public class WorldGenRegion implements WorldGenLevel {
+     private Supplier<String> currentlyGenerating;
+     private final AtomicLong subTickCount = new AtomicLong();
+     private static final ResourceLocation WORLDGEN_REGION_RANDOM = new ResourceLocation("worldgen_region_random");
+    private ChunkAccess[] chunksArr; // Mirai - lithium: gen
+    private int minChunkX, minChunkZ; // Mirai - lithium: gen
+ 
+     public WorldGenRegion(ServerLevel world, List<ChunkAccess> chunks, ChunkStatus status, int placementRadius) {
+         this.generatingStatus = status;
+@@ -103,6 +106,12 @@ public class WorldGenRegion implements WorldGenLevel {
+             this.lastPos = ((ChunkAccess) chunks.get(chunks.size() - 1)).getPos();
+             this.structureManager = world.structureManager().forWorldGenRegion(this);
+         }
+        // Mirai start - lithium: gen
+        this.minChunkX = this.firstPos.x;
+        this.minChunkZ = this.firstPos.z;
+
+        this.chunksArr = chunks.toArray(new ChunkAccess[0]);
+        // Mirai end
+     }
+ 
+     public boolean isOldChunkAround(ChunkPos chunkPos, int checkRadius) {
+@@ -118,11 +127,33 @@ public class WorldGenRegion implements WorldGenLevel {
+         this.currentlyGenerating = structureName;
+     }
+ 
+    // Mirai start - lithium: gen
+    /**
+     * @reason Use the chunk array for faster access
+     * @author SuperCoder7979, 2No2Name
+     */
+     @Override
+     public ChunkAccess getChunk(int chunkX, int chunkZ) {
+-        return this.getChunk(chunkX, chunkZ, ChunkStatus.EMPTY);
+        int x = chunkX - this.minChunkX;
+        int z = chunkZ - this.minChunkZ;
+        int w = this.size;
+
+        if (x >= 0 && z >= 0 && x < w && z < w) {
+            return this.chunksArr[x + z * w];
+        } else {
+            throw new NullPointerException("No chunk exists at " + new ChunkPos(chunkX, chunkZ));
+        }
+     }
+ 
+    /**
+     * Use our chunk fetch function
+     */
+    public ChunkAccess getChunk(BlockPos pos) {
+        // Skip checking chunk.getStatus().isAtLeast(ChunkStatus.EMPTY) here, because it is always true
+        return this.getChunk(Pos.ChunkCoord.fromBlockCoord(pos.getX()), Pos.ChunkCoord.fromBlockCoord(pos.getZ()));
+    }
+    // Mirai end
+
+     @Nullable
+     @Override
+     public ChunkAccess getChunk(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) {
+@@ -178,10 +209,24 @@ public class WorldGenRegion implements WorldGenLevel {
+     }
+     // Paper end
+ 
+    // Mirai start - lithium: gen
+    /**
+     * @reason Avoid pointer de-referencing, make method easier to inline
+     * @author JellySquid
+     */
+     @Override
+     public BlockState getBlockState(BlockPos pos) {
+-        return this.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ())).getBlockState(pos);
+        int x = (Pos.ChunkCoord.fromBlockCoord(pos.getX())) - this.minChunkX;
+        int z = (Pos.ChunkCoord.fromBlockCoord(pos.getZ())) - this.minChunkZ;
+        int w = this.size;
+
+        if (x >= 0 && z >= 0 && x < w && z < w) {
+            return this.chunksArr[x + z * w].getBlockState(pos);
+        } else {
+            throw new NullPointerException("No chunk exists at " + new ChunkPos(pos));
+        }
+     }
+    // Mirai end
+ 
+     @Override
+     public FluidState getFluidState(BlockPos pos) {
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+index df1db87d2dd5076fccea6a1ac9271a9d786729bb..a9be97c61714597dd68fbe196c90b214a4cd9647 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+@@ -67,6 +67,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
+     public final Registry<NormalNoise.NoiseParameters> noises;
+     public final Holder<NoiseGeneratorSettings> settings;
+     private final Aquifer.FluidPicker globalFluidPicker;
+    private int cachedSeaLevel; // Mirai - lithium: gen
+ 
+     public NoiseBasedChunkGenerator(Registry<StructureSet> structureSetRegistry, Registry<NormalNoise.NoiseParameters> noiseRegistry, BiomeSource populationSource, Holder<NoiseGeneratorSettings> holder) {
+         super(structureSetRegistry, Optional.empty(), populationSource);
+@@ -83,6 +84,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
+         this.globalFluidPicker = (j, k, l) -> {
+             return k < Math.min(-54, i) ? aquifer_b : aquifer_b1;
+         };
+        this.cachedSeaLevel = ((NoiseGeneratorSettings) this.settings.value()).seaLevel(); // Mirai - lithium: gen
+     }
+ 
+     @Override
+@@ -398,10 +400,19 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
+         return ((NoiseGeneratorSettings) this.settings.value()).noiseSettings().height();
+     }
+ 
+    // Mirai start - lithium: gen
+    /**
+     * Use cached sea level instead of retrieving from the registry every time.
+     * This method is called for every block in the chunk so this will save a lot of registry lookups.
+     *
+     * @author SuperCoder79
+     * @reason avoid registry lookup
+     */
+     @Override
+     public int getSeaLevel() {
+-        return ((NoiseGeneratorSettings) this.settings.value()).seaLevel();
+        return this.cachedSeaLevel;
+     }
+    // Mirai end
+ 
+     @Override
+     public int getMinY() {
--- a/patches/server/0084-PaperPR-Stop-large-look-changes-from-crashing-the-se.patch
+++ b/patches/server/0084-PaperPR-Stop-large-look-changes-from-crashing-the-se.patch
--- a/patches/server/0085-PaperPR-Add-more-collision-code-skipping-logic.patch
+++ b/patches/server/0085-PaperPR-Add-more-collision-code-skipping-logic.patch
--- a/patches/server/0086-vmp-use-linked-map-for-entity-trackers-for-faster-it.patch
+++ b/patches/server/0086-vmp-use-linked-map-for-entity-trackers-for-faster-it.patch
--- a/patches/server/0087-c2me-reduce_allocs.patch
+++ b/patches/server/0087-c2me-reduce_allocs.patch
@@ -0,0 +1,258 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: ishland <ishlandmc@yeah.net>
+Date: Mon, 24 Jan 2022 10:56:10 -0500
+Subject: [PATCH] c2me: reduce_allocs
+
+Copyright (c) 2021-2022 ishland
+
+Original code by RelativityMC, licensed under MIT
+You can find the original code on https://github.com/RelativityMC/C2ME-fabric (Yarn mappings)
+
+diff --git a/src/main/java/com/ishland/c2me/opts/allocs/common/ObjectCachingUtils.java b/src/main/java/com/ishland/c2me/opts/allocs/common/ObjectCachingUtils.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b1229bae2e74d22065c723c6d3eaf9a97d572b04
+--- /dev/null
+++ b/src/main/java/com/ishland/c2me/opts/allocs/common/ObjectCachingUtils.java
+@@ -0,0 +1,23 @@
+package com.ishland.c2me.opts.allocs.common;
+
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+import java.util.BitSet;
+import java.util.function.IntFunction;
+
+public class ObjectCachingUtils {
+
+    private static final IntFunction<BitSet> bitSetConstructor = BitSet::new;
+
+    public static ThreadLocal<Int2ObjectOpenHashMap<BitSet>> BITSETS = ThreadLocal.withInitial(Int2ObjectOpenHashMap::new);
+
+    private ObjectCachingUtils() {
+    }
+
+    public static BitSet getCachedOrNewBitSet(int bits) {
+        final BitSet bitSet = BITSETS.get().computeIfAbsent(bits, bitSetConstructor);
+        bitSet.clear();
+        return bitSet;
+    }
+
+}
+diff --git a/src/main/java/com/ishland/c2me/opts/allocs/common/PooledFeatureContext.java b/src/main/java/com/ishland/c2me/opts/allocs/common/PooledFeatureContext.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4c84006c90bda4849b27879d5218f98e6d98f1dc
+--- /dev/null
+++ b/src/main/java/com/ishland/c2me/opts/allocs/common/PooledFeatureContext.java
+@@ -0,0 +1,68 @@
+package com.ishland.c2me.opts.allocs.common;
+
+import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
+import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
+import net.minecraft.world.level.levelgen.feature.configurations.FeatureConfiguration;
+
+public class PooledFeatureContext<FC extends FeatureConfiguration> extends FeaturePlaceContext<FC> {
+
+    public static final ThreadLocal<SimpleObjectPool<PooledFeatureContext<?>>> POOL = ThreadLocal.withInitial(() -> new SimpleObjectPool<>(unused -> new PooledFeatureContext<>(), unused -> {}, 2048));
+
+    private Optional<ConfiguredFeature<?, ?>> feature;
+    private WorldGenLevel world;
+    private ChunkGenerator generator;
+    private RandomSource random;
+    private BlockPos origin;
+    private FC config;
+
+    public PooledFeatureContext() {
+        super(null, null, null, null, null, null);
+    }
+
+    public void reInit(Optional<ConfiguredFeature<?, ?>> feature, WorldGenLevel world, ChunkGenerator generator, RandomSource random, BlockPos origin, FC config) {
+        this.feature = feature;
+        this.world = world;
+        this.generator = generator;
+        this.random = random;
+        this.origin = origin;
+        this.config = config;
+    }
+
+    public void reInit() {
+        this.feature = null;
+        this.world = null;
+        this.generator = null;
+        this.random = null;
+        this.origin = null;
+        this.config = null;
+    }
+
+    public WorldGenLevel level() {
+        return this.world;
+    }
+
+    public ChunkGenerator chunkGenerator() {
+        return this.generator;
+    }
+
+    public RandomSource random() {
+        return this.random;
+    }
+
+    public BlockPos origin() {
+        return this.origin;
+    }
+
+    public FC config() {
+        return this.config;
+    }
+
+    public Optional<ConfiguredFeature<?, ?>> topFeature() {
+        return this.feature;
+    }
+}
+diff --git a/src/main/java/com/ishland/c2me/opts/allocs/common/SimpleObjectPool.java b/src/main/java/com/ishland/c2me/opts/allocs/common/SimpleObjectPool.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b989019847f73ba3af57f7428699c9c869d6332f
+--- /dev/null
+++ b/src/main/java/com/ishland/c2me/opts/allocs/common/SimpleObjectPool.java
+@@ -0,0 +1,57 @@
+package com.ishland.c2me.opts.allocs.common;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class SimpleObjectPool<T> {
+
+    private final Function<SimpleObjectPool<T>, T> constructor;
+    private final Consumer<T> initializer;
+    private final int size;
+
+    private final Object[] cachedObjects;
+    private int allocatedCount = 0;
+
+    public SimpleObjectPool(Function<SimpleObjectPool<T>, T> constructor, Consumer<T> initializer, int size) {
+        this.constructor = Objects.requireNonNull(constructor);
+        this.initializer = Objects.requireNonNull(initializer);
+        Preconditions.checkArgument(size > 0);
+        this.cachedObjects = new Object[size];
+        this.size = size;
+
+        for (int i = 0; i < size; i++) {
+            final T object = constructor.apply(this);
+            this.cachedObjects[i] = object;
+        }
+    }
+
+    public T alloc() {
+        final T object;
+        synchronized (this) {
+            if (this.allocatedCount >= this.size) { // oversized, falling back to normal alloc
+                object = this.constructor.apply(this);
+                return object;
+            }
+
+            // get an object from the array
+            final int ordinal = this.allocatedCount++;
+            object = (T) this.cachedObjects[ordinal];
+            this.cachedObjects[ordinal] = null;
+        }
+
+        this.initializer.accept(object); // initialize the object
+
+        return object;
+    }
+
+    public void release(T object) {
+        synchronized (this) {
+            if (this.allocatedCount == 0) return; // pool is full
+            this.cachedObjects[--this.allocatedCount] = object; // store the object into the pool
+        }
+    }
+
+}
+diff --git a/src/main/java/net/minecraft/resources/ResourceLocation.java b/src/main/java/net/minecraft/resources/ResourceLocation.java
+index 7017dd42f832d928f1008a05f01701667d951644..4e767dd8f9594e8a8f5d71e2bfd8c976c0032f98 100644
+--- a/src/main/java/net/minecraft/resources/ResourceLocation.java
+++ b/src/main/java/net/minecraft/resources/ResourceLocation.java
+@@ -27,6 +27,7 @@ public class ResourceLocation implements Comparable<ResourceLocation> {
+     public static final String REALMS_NAMESPACE = "realms";
+     protected final String namespace;
+     protected final String path;
+    private String cachedString = null; // Mirai - c2me: opts allocs
+ 
+     protected ResourceLocation(String[] id) {
+         this.namespace = StringUtils.isEmpty(id[0]) ? "minecraft" : id[0];
+@@ -99,7 +100,16 @@ public class ResourceLocation implements Comparable<ResourceLocation> {
+ 
+     @Override
+     public String toString() {
+-        return this.namespace + ":" + this.path;
+        // Mirai start - c2me: opts allocs
+        /**
+         * @author ishland
+         * @reason cache toString
+         */
+        if (this.cachedString != null) return this.cachedString;
+        final String s = this.namespace + ":" + this.path;
+        this.cachedString = s;
+        return s;
+        // Mirai end
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/ConfiguredFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/ConfiguredFeature.java
+index 2f67705132df06ae6231dd1b89a4f61a90616ef5..1013df19df55316200169f6c3deec8876ea4686a 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/feature/ConfiguredFeature.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/ConfiguredFeature.java
+@@ -12,6 +12,10 @@ import net.minecraft.util.RandomSource;
+ import net.minecraft.world.level.WorldGenLevel;
+ import net.minecraft.world.level.chunk.ChunkGenerator;
+ import net.minecraft.world.level.levelgen.feature.configurations.FeatureConfiguration;
+// Mirai start - c2me: opts allocs
+import com.ishland.c2me.opts.allocs.common.PooledFeatureContext;
+import com.ishland.c2me.opts.allocs.common.SimpleObjectPool;
+// Mirai end
+ 
+ public record ConfiguredFeature<FC extends FeatureConfiguration, F extends Feature<FC>>(F feature, FC config) {
+     public static final Codec<ConfiguredFeature<?, ?>> DIRECT_CODEC = Registry.FEATURE.byNameCodec().dispatch((configuredFeature) -> {
+@@ -21,7 +25,22 @@ public record ConfiguredFeature<FC extends FeatureConfiguration, F extends Featu
+     public static final Codec<HolderSet<ConfiguredFeature<?, ?>>> LIST_CODEC = RegistryCodecs.homogeneousList(Registry.CONFIGURED_FEATURE_REGISTRY, DIRECT_CODEC);
+ 
+     public boolean place(WorldGenLevel world, ChunkGenerator chunkGenerator, RandomSource random, BlockPos origin) {
+-        return this.feature.place(this.config, world, chunkGenerator, random, origin);
+        // Mirai start - c2me: opts allocs
+        /**
+         * @author ishland
+         * @reason pool FeatureContext
+         */
+        if (!world.ensureCanWrite(origin)) return false;
+        final SimpleObjectPool<PooledFeatureContext<?>> pool = PooledFeatureContext.POOL.get();
+        final PooledFeatureContext<FC> context = (PooledFeatureContext<FC>) pool.alloc();
+        try {
+            context.reInit(java.util.Optional.empty(), world, chunkGenerator, random, origin, this.config);
+            return this.feature.place(context);
+        } finally {
+            context.reInit();
+            pool.release(context);
+        }
+        // Mirai end
+     }
+ 
+     public Stream<ConfiguredFeature<?, ?>> getFeatures() {
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/OreFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/OreFeature.java
+index b2f36a998437e2a63a3cbc6c3aa95b1402bff2f1..d69a57f67eeb99f3db4f80d13b9f0276ce4603af 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/feature/OreFeature.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/feature/OreFeature.java
+@@ -54,7 +54,7 @@ public class OreFeature extends Feature<OreConfiguration> {
+ 
+     protected boolean doPlace(WorldGenLevel world, RandomSource randomSource, OreConfiguration config, double startX, double endX, double startZ, double endZ, double startY, double endY, int x, int y, int z, int horizontalSize, int verticalSize) {
+         int i = 0;
+-        BitSet bitSet = new BitSet(horizontalSize * verticalSize * horizontalSize);
+        BitSet bitSet = com.ishland.c2me.opts.allocs.common.ObjectCachingUtils.getCachedOrNewBitSet(horizontalSize * verticalSize * horizontalSize); // Mirai - c2me: opts allocs
+         BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos();
+         int j = config.size;
+         double[] ds = new double[j * 4];
--- a/patches/server/0088-lithium-ai.sensor.secondary_poi.patch
+++ b/patches/server/0088-lithium-ai.sensor.secondary_poi.patch
--- a/patches/server/0089-Fix-tick-function-tag-running-before-load.patch
+++ b/patches/server/0089-Fix-tick-function-tag-running-before-load.patch
--- a/patches/server/0090-lithium-suffocation.patch
+++ b/patches/server/0090-lithium-suffocation.patch
--- a/patches/server/0091-Optimize-default-values-for-configs.patch
+++ b/patches/server/0091-Optimize-default-values-for-configs.patch
--- a/patches/server/0092-Configurable-map-update-interval.patch
+++ b/patches/server/0092-Configurable-map-update-interval.patch
--- a/patches/server/0093-Fix-hunger-saturation-depleting-on-peaceful.patch
+++ b/patches/server/0093-Fix-hunger-saturation-depleting-on-peaceful.patch
--- a/patches/server/0094-Fix-mobs-attacking-themselves.patch
+++ b/patches/server/0094-Fix-mobs-attacking-themselves.patch
--- a/patches/server/0095-Fix-brewing-stands-resetting-their-brewTime-when-bei.patch
+++ b/patches/server/0095-Fix-brewing-stands-resetting-their-brewTime-when-bei.patch
--- a/patches/server/0096-lithium-world.tick_scheduler.patch
+++ b/patches/server/0096-lithium-world.tick_scheduler.patch
--- a/patches/server/0097-Save-Json-list-asynchronously.patch
+++ b/patches/server/0097-Save-Json-list-asynchronously.patch
--- a/patches/server/0098-Swaps-the-predicate-order-of-collision.patch
+++ b/patches/server/0098-Swaps-the-predicate-order-of-collision.patch
--- a/patches/server/0099-Fix-head-rotation-packet-spam.patch
+++ b/patches/server/0099-Fix-head-rotation-packet-spam.patch
--- a/patches/server/0100-Cache-block-break-animation-packet.patch
+++ b/patches/server/0100-Cache-block-break-animation-packet.patch
--- a/patches/server/0101-Use-more-fastutil-data-structures.patch
+++ b/patches/server/0101-Use-more-fastutil-data-structures.patch