Repo-Mirror/Leaf
9
0
Fork 0
mirror of https://github.com/Winds-Studio/Leaf.git synced 2025-12-23 00:49:31 +00:00
Code Issues Releases Activity
Files
b30efc3670627620fa5919c4f9eabaf114a2b7d1
Leaf/patches/server/0076-Hearse-Remove-some-fixes-and-await-entity-task.patch
Dreeam b30efc3670 Updated Upstream (Hearse)
2023-01-27 08:39:13 -05:00

236 lines
11 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: wangxyper <wangxyper@163.com>
Date: Sat, 21 Jan 2023 09:49:43 +0800
Subject: [PATCH] Hearse: Remove some fixes and await entity task
Original license: MIT
Original project: https://github.com/Era4FunMC/Hearse
diff --git a/src/main/java/co/earthme/hearse/server/ServerEntityTickHook.java b/src/main/java/co/earthme/hearse/server/ServerEntityTickHook.java
index c0d235e7227db0be6c6f753d8a6e13ad2716f798..891a9167e4072d6ce5b526b1676d8ecb836c8733 100644
--- a/src/main/java/co/earthme/hearse/server/ServerEntityTickHook.java
+++ b/src/main/java/co/earthme/hearse/server/ServerEntityTickHook.java
@@ -5,37 +5,37 @@ import co.earthme.hearse.HearseConfig;
import co.earthme.hearse.concurrent.WorkerThreadFactory;
import co.earthme.hearse.concurrent.WorkerThreadPoolExecutor;
import co.earthme.hearse.concurrent.threadfactory.DefaultWorkerFactory;
-import co.earthme.hearse.util.ArrayListBlockingQueue;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.entity.Entity;
-import net.minecraft.world.entity.player.Player;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.LockSupport;
public class ServerEntityTickHook {
private static final Logger logger = LogManager.getLogger();
- private static volatile boolean firstTick = false;
private static final WorkerThreadFactory defFactory = new DefaultWorkerFactory("entity");
- private static final AtomicInteger threadId = new AtomicInteger();
private static WorkerThreadPoolExecutor worker;
- private static boolean asyncEntityEnabled;
+ private static boolean asyncEntityEnabled = true;
+ private static boolean awaitEntityTasks = true;
+ private static final AtomicInteger taskCounter = new AtomicInteger(0);
- public static void executeAsyncTask(Runnable task){
- if (!asyncEntityEnabled){
- throw new RejectedExecutionException();
+ //To prevent the chunk system error.This is necessary
+ public static void awaitEntityTasks(){
+ while (taskCounter.get() > 0){
+ LockSupport.parkNanos("Await entities",1000000);
}
- worker.execute(task);
}
public static void init(){
- boolean asyncEntityEnabled1 = HearseConfig.getBoolean("optimizations.enable-async-entity",true);
- final int workerCount = HearseConfig.getInt("workers.async-entity-worker-count",Runtime.getRuntime().availableProcessors());
- if (asyncEntityEnabled1){
+ asyncEntityEnabled = HearseConfig.getBoolean("optimizations.enable-parallel-entity",asyncEntityEnabled);
+ awaitEntityTasks = HearseConfig.getBoolean("optimizations.await-parallel-entity-tasks",awaitEntityTasks);
+ if (asyncEntityEnabled){
+ final int workerCount = HearseConfig.getInt("workers.async-entity-worker-count",Runtime.getRuntime().availableProcessors());
worker = new WorkerThreadPoolExecutor(
workerCount,
workerCount,
@@ -46,47 +46,33 @@ public class ServerEntityTickHook {
);
Hearse.getWorkerManager().addWorker("entity",worker);
}
- asyncEntityEnabled = asyncEntityEnabled1;
- }
-
- public static void executeAsyncTaskWithMainThreadCallback(Runnable task,Runnable callBack){
- if (!asyncEntityEnabled){
- throw new IllegalStateException();
- }
- worker.executeWithSubTask(task,callBack);
- }
-
- public static void callTickStart(){
- if (!firstTick){
- firstTick = true;
- return;
- }
- if (!asyncEntityEnabled){
- return;
- }
- worker.runAllSubTasks();
}
public static void callAsyncEntityTick(Entity entity, ServerLevel level){
MinecraftServer.getServer().executeMidTickTasks();
+ taskCounter.getAndIncrement();
Runnable task = ()->{
- entity.activatedPriorityReset = false;
- if (!entity.isRemoved()) {
- entity.checkDespawn();
- Entity entity1 = entity.getVehicle();
- if (entity1 != null) {
- if (!entity1.isRemoved() && entity1.hasPassenger(entity)) {
- return;
+ try {
+ entity.activatedPriorityReset = false;
+ if (!entity.isRemoved()) {
+ entity.checkDespawn();
+ Entity entity1 = entity.getVehicle();
+ if (entity1 != null) {
+ if (!entity1.isRemoved() && entity1.hasPassenger(entity)) {
+ return;
+ }
+ entity.stopRiding();
+ }
+ try {
+ level.tickNonPassenger(entity);
+ } catch (Throwable throwable) {
+ if (throwable instanceof ThreadDeath) throw throwable;
+ level.getCraftServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerInternalException(throwable.getMessage(), throwable)));
+ throwable.printStackTrace();
}
- entity.stopRiding();
- }
- try {
- level.tickNonPassenger(entity);
- } catch (Throwable throwable) {
- if (throwable instanceof ThreadDeath) throw throwable;
- level.getCraftServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerInternalException(throwable.getMessage(), throwable)));
- throwable.printStackTrace();
}
+ }finally {
+ taskCounter.getAndDecrement();
}
};
if (!asyncEntityEnabled){
diff --git a/src/main/java/co/earthme/hearse/server/ServerLevelTickHook.java b/src/main/java/co/earthme/hearse/server/ServerLevelTickHook.java
index 759b6dc9c719c6ff63348f9eacc760f8cef3163e..4c85bf8e4705a781a55a048f0b0541f0d32e2f07 100644
--- a/src/main/java/co/earthme/hearse/server/ServerLevelTickHook.java
+++ b/src/main/java/co/earthme/hearse/server/ServerLevelTickHook.java
@@ -20,13 +20,11 @@ import java.util.function.BooleanSupplier;
public class ServerLevelTickHook {
private static final DefaultWorkerFactory workerFactory = new DefaultWorkerFactory("world");
private static WorkerThreadPoolExecutor worker;
- private static boolean enabledParaWorld;
- private static volatile boolean inited = false;
private static final AtomicInteger activeTaskCount = new AtomicInteger();
private static final Logger logger = LogManager.getLogger();
public static void initWorker(){
- enabledParaWorld = HearseConfig.getBoolean("optimizations.enableparallelworldtick",true);
+ boolean enabledParaWorld = HearseConfig.getBoolean("optimizations.enableparallelworldtick", true);
if (enabledParaWorld){
worker = new WorkerThreadPoolExecutor(
MinecraftServer.getServer().levels.size(),
@@ -43,16 +41,11 @@ public class ServerLevelTickHook {
logger.warn("World worker name:{}.This can help you to slove the lag problems when you using parallel world ticking",worker.getName());
}
}
- inited = true;
- }
-
- public static boolean isInited(){
- return inited;
}
public static void callWorldTick(ServerLevel worldserver, BooleanSupplier shouldKeepTicking){
activeTaskCount.getAndIncrement();
- worker.execute(()->{
+ Runnable task = () -> {
try {
try {
worldserver.tick(shouldKeepTicking);
@@ -66,7 +59,14 @@ public class ServerLevelTickHook {
}finally {
activeTaskCount.getAndDecrement();
}
- });
+ };
+
+ if (worker == null){
+ task.run();
+ return;
+ }
+
+ worker.execute(task);
}
public static void awaitWorldTicKTasks(){
diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
index 42599340856aa5ffcfae2281684174ca4dee289a..f0f164c6c95c0abde63f1327335af94148910152 100644
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
@@ -1,7 +1,6 @@
package net.minecraft.server;
import co.earthme.hearse.Hearse;
-import co.earthme.hearse.HearseConfig;
import co.earthme.hearse.server.ServerEntityTickHook;
import co.earthme.hearse.server.ServerLevelTickHook;
import com.google.common.base.Splitter;
@@ -1397,7 +1396,6 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
//isOversleep = false;MinecraftTimings.serverOversleep.stopTiming(); // Purpur
// Paper end
new com.destroystokyo.paper.event.server.ServerTickStartEvent(this.tickCount+1).callEvent(); // Paper
- ServerEntityTickHook.callTickStart();
++this.tickCount;
this.tickChildren(shouldKeepTicking);
@@ -1535,6 +1533,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
//this.profiler.push("tick"); // Purpur
ServerLevelTickHook.callWorldTick(worldserver,shouldKeepTicking);
}
+ ServerEntityTickHook.awaitEntityTasks();
ServerLevelTickHook.awaitWorldTicKTasks();
this.isIteratingOverLevels = false; // Paper
diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
index e73a7685cc78af407131388acff62c3427fd4618..becac3c1087c77b289c3b0a721c4146bea046e51 100644
--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
@@ -498,14 +498,11 @@ public class ServerChunkCache extends ChunkSource {
}
};
- //C2ME --general issue fixes
- synchronized (this.schedulingMutex){
- this.level.chunkTaskScheduler.scheduleChunkLoad(
- chunkX, chunkZ, leastStatus, true,
- isUrgent ? PrioritisedExecutor.Priority.BLOCKING : PrioritisedExecutor.Priority.NORMAL,
- complete
- );
- }
+ this.level.chunkTaskScheduler.scheduleChunkLoad(
+ chunkX, chunkZ, leastStatus, true,
+ isUrgent ? PrioritisedExecutor.Priority.BLOCKING : PrioritisedExecutor.Priority.NORMAL,
+ complete
+ );
return ret;
} else {
Reference in New Issue View Git Blame Copy Permalink