Move patches around

2021-06-11 14:02:28 +02:00 · 2021-06-11 14:02:28 +02:00 · 4d225813a1
commit 4d225813a1
parent 73bcb74f23
1895 changed files with 212111 additions and 0 deletions
--- a/patches/server-unmapped/0439-Remove-streams-from-PairedQueue.patch
+++ b/patches/server-unmapped/0439-Remove-streams-from-PairedQueue.patch
@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <spottedleaf@spottedleaf.dev>
+Date: Mon, 6 Apr 2020 18:10:43 -0700
+Subject: [PATCH] Remove streams from PairedQueue
+
+We shouldn't be doing stream calls just to see if the queue is
+empty. This creates loads of garbage thanks to how often it's called.
+
+diff --git a/src/main/java/net/minecraft/util/thread/PairedQueue.java b/src/main/java/net/minecraft/util/thread/PairedQueue.java
+index 024b414aae32c8ad32bdf031361257fc74b80eb3..56c9efa78ceeac499182eb401e605a60dad12182 100644
+--- a/src/main/java/net/minecraft/util/thread/PairedQueue.java
+++ b/src/main/java/net/minecraft/util/thread/PairedQueue.java
+@@ -20,32 +20,30 @@ public interface PairedQueue<T, F> {
+ 
+     public static final class a implements PairedQueue<PairedQueue.b, Runnable> {
+ 
+-        private final List<Queue<Runnable>> a;
+        private final List<Queue<Runnable>> a; private final List<Queue<Runnable>> getQueues() { return this.a; } // Paper - OBFHELPER
+ 
+         public a(int i) {
+-            this.a = (List) IntStream.range(0, i).mapToObj((j) -> {
+-                return Queues.newConcurrentLinkedQueue();
+-            }).collect(Collectors.toList());
+            // Paper start - remove streams
+            this.a = new java.util.ArrayList<>(i); // queues
+            for (int j = 0; j < i; ++j) {
+                this.getQueues().add(Queues.newConcurrentLinkedQueue());
+            }
+            // Paper end - remove streams
+         }
+ 
+         @Nullable
+         @Override
+         public Runnable a() {
+-            Iterator iterator = this.a.iterator();
+-
+-            Runnable runnable;
+-
+-            do {
+-                if (!iterator.hasNext()) {
+-                    return null;
+            // Paper start - remove iterator creation
+            for (int i = 0, len = this.getQueues().size(); i < len; ++i) {
+                Queue<Runnable> queue = this.getQueues().get(i);
+                Runnable ret = queue.poll();
+                if (ret != null) {
+                    return ret;
+                 }
+-
+-                Queue<Runnable> queue = (Queue) iterator.next();
+-
+-                runnable = (Runnable) queue.poll();
+-            } while (runnable == null);
+-
+-            return runnable;
+            }
+            return null;
+            // Paper end - remove iterator creation
+         }
+ 
+         public boolean a(PairedQueue.b pairedqueue_b) {
+@@ -57,7 +55,16 @@ public interface PairedQueue<T, F> {
+ 
+         @Override
+         public boolean b() {
+-            return this.a.stream().allMatch(Collection::isEmpty);
+            // Paper start - remove streams
+            // why are we doing streams every time we might want to execute a task?
+            for (int i = 0, len = this.getQueues().size(); i < len; ++i) {
+                Queue<Runnable> queue = this.getQueues().get(i);
+                if (!queue.isEmpty()) {
+                    return false;
+                }
+            }
+            return true;
+            // Paper end - remove streams
+         }
+     }
+