From e876103942278b4a392634a2e9b204e02d2993a3 Mon Sep 17 00:00:00 2001
From: Spottedleaf <Spottedleaf@users.noreply.github.com>
Date: Tue, 3 Oct 2023 06:18:27 -0700
Subject: [PATCH] Region profiler

Profiling for a region starts with the /profiler command.
The usage for /profiler:
/profiler <world> <block x> <block z> <time in s> [radius, default 100 blocks]

Any region within the radius of the specified block coordinates
will be profiled. The profiling will stop after the specified
time has passed.

Once the profiler finishes, it will place a report in
the directory ./profiler/<id>.

Since regions can split into smaller regions, or merge into
other regions, the profiler will track this information. If
a profiled region splits, then all of the regions it splits
into are attached to the same profiler instance. If a profiled
region merges into another region, then the merged region is
profiled. This information is tracked and logged into the
"journal.txt" file contained in the report directory. The
journal tracks the region ids for the merge/split operations.

Region profiling is placed into the "region-X.txt" file where
X is the region id inside the profile directory. The header
of the file describes some stats about the region, namely
total profiling duration, ticks, utilisation, TPS, and MSPT.

Then, the timing tree is follows. The format is as specified:

There are two types of data recorded: Timers and Counters.

Timers are specified as follows:
<indent><name> X% total, Y% parent, self A% total, self B% children, avg D sum E, Fms raw sum
The above specifies the format for a named timer.

The <indent> specifies the number of parent timers.

"X" represents the percentage of time the timer took relative
to the entire profiling instance.

"Y" represents the percentage of time the timer took relative
to its _parents_ timer. For example:
```
Full Tick 100.000% total, 100.000% parent, self 0.889% total, self 0.889% children, avg 200.000 sum 200, 401.300ms raw sum
|+++Tick World: minecraft:overworld 81.409% total, 81.409% parent, self 1.873% total, self 2.301% children, avg 1.000 sum 200, 326.694ms raw sum
|---|---Entity Tick 56.784% total, 69.751% parent, self 6.049% total, self 10.652% children, avg 1.000 sum 200, 227.874ms raw sum
```
"Entity Tick" measured 69.751% of the time for the "Tick World: minecraft:overworld" timer.

"A" represents the self time relative to the entire profiling instance.
The self time is the amount of time for a timer that is _not_ measured
by a child timer.

"B" represents the self time relative to its _parents_ timer.

"D" represents the average number of times the timer is invoked relative to
its parent.
For example:
```
|---|---|---Entity Tick: bat 2.642% total, 7.343% parent, self 2.642% total, self 100.000% children, avg 14.975 sum 2,995, 23.127ms raw sum
```
In this case, an average of 14.975 bats were ticked for every
time the "Entity Tick" timer was invoked.

"E" represents the total number of times the timer is invoked.

"F" represents the total raw time accumulated by the timer.

Counters are specified as follows:
<indent>#<name> avg X sum Y

The X is the average number of times the counter is invoked
relative to the parent, exactly similar to the D field of Timers,
where Y is the total number of times the counter is invoked.
---
 patches/server/0003-Threaded-Regions.patch |  618 ++----
 patches/server/0019-Region-profiler.patch  | 1958 ++++++++++++++++++++
 2 files changed, 2072 insertions(+), 504 deletions(-)
 create mode 100644 patches/server/0019-Region-profiler.patch

diff --git a/patches/server/0003-Threaded-Regions.patch b/patches/server/0003-Threaded-Regions.patch
index e245224..d0874d2 100644
--- a/patches/server/0003-Threaded-Regions.patch
+++ b/patches/server/0003-Threaded-Regions.patch
@@ -1351,485 +1351,6 @@ index 0000000000000000000000000000000000000000..63688716244066581d5b505703576e33
 +
 +    private TimeUtil() {}
 +}
-diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java b/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..1083a3dc0fc824da176e6ee64654b8c01b80ca4b
---- /dev/null
-+++ b/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java
-@@ -0,0 +1,89 @@
-+package ca.spottedleaf.leafprofiler;
-+
-+import it.unimi.dsi.fastutil.ints.Int2IntMap;
-+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
-+import java.util.ArrayDeque;
-+import java.util.ArrayList;
-+import java.util.Arrays;
-+import java.util.Iterator;
-+import java.util.List;
-+
-+public final class LProfileGraph {
-+
-+    public static final int ROOT_NODE = 0;
-+    // Array idx is the graph node id, where the int->int mapping is a mapping of profile timer id to graph node id
-+    private Int2IntOpenHashMap[] nodes;
-+    private int nodeCount;
-+
-+    public LProfileGraph() {
-+        final Int2IntOpenHashMap[] nodes = new Int2IntOpenHashMap[16];
-+        nodes[ROOT_NODE] = new Int2IntOpenHashMap();
-+
-+        this.nodes = nodes;
-+        this.nodeCount = 1;
-+    }
-+
-+    public static record GraphNode(GraphNode parent, int nodeId, int timerId) {}
-+
-+    public List<GraphNode> getDFS() {
-+        final List<GraphNode> ret = new ArrayList<>();
-+        final ArrayDeque<GraphNode> queue = new ArrayDeque<>();
-+
-+        queue.addFirst(new GraphNode(null, ROOT_NODE, -1));
-+        final Int2IntOpenHashMap[] nodes = this.nodes;
-+
-+        GraphNode graphNode;
-+        while ((graphNode = queue.pollFirst()) != null) {
-+            ret.add(graphNode);
-+
-+            final int parent = graphNode.nodeId;
-+
-+            final Int2IntOpenHashMap children = nodes[parent];
-+
-+            for (final Iterator<Int2IntMap.Entry> iterator = children.int2IntEntrySet().fastIterator(); iterator.hasNext();) {
-+                final Int2IntMap.Entry entry = iterator.next();
-+                queue.addFirst(new GraphNode(graphNode, entry.getIntValue(), entry.getIntKey()));
-+            }
-+        }
-+
-+        return ret;
-+    }
-+
-+    private int createNode(final int parent, final int timerId) {
-+        Int2IntOpenHashMap[] nodes = this.nodes;
-+
-+        final Int2IntOpenHashMap node = nodes[parent];
-+
-+        final int newNode = this.nodeCount;
-+        final int prev = node.putIfAbsent(timerId, newNode);
-+
-+        if (prev != 0) {
-+            // already exists
-+            return prev;
-+        }
-+
-+        // insert new node
-+        ++this.nodeCount;
-+
-+        if (newNode >= nodes.length) {
-+            this.nodes = (nodes = Arrays.copyOf(nodes, nodes.length * 2));
-+        }
-+
-+        nodes[newNode] = new Int2IntOpenHashMap();
-+
-+        return newNode;
-+    }
-+
-+    public int getOrCreateNode(final int parent, final int timerId) {
-+        // note: requires parent node to exist
-+        final Int2IntOpenHashMap[] nodes = this.nodes;
-+
-+        final int mapping = nodes[parent].get(timerId);
-+
-+        if (mapping != 0) {
-+            return mapping;
-+        }
-+
-+        return this.createNode(parent, timerId);
-+    }
-+}
-diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java b/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..66200c6f4bcf27d060eedf066f56b70bd0cc3929
---- /dev/null
-+++ b/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java
-@@ -0,0 +1,59 @@
-+package ca.spottedleaf.leafprofiler;
-+
-+import java.util.Arrays;
-+import java.util.concurrent.ConcurrentHashMap;
-+
-+public final class LProfilerRegistry {
-+
-+    // volatile required to ensure correct publishing when resizing
-+    private volatile ProfilerEntry[] typesById = new ProfilerEntry[16];
-+    private int totalEntries;
-+    private final ConcurrentHashMap<String, ProfilerEntry> nameToEntry = new ConcurrentHashMap<>();
-+
-+    public LProfilerRegistry() {
-+
-+    }
-+
-+    public ProfilerEntry getById(final int id) {
-+        final ProfilerEntry[] entries = this.typesById;
-+
-+        return id < 0 || id >= entries.length ? null : entries[id];
-+    }
-+
-+    public ProfilerEntry getByName(final String name) {
-+        return this.nameToEntry.get(name);
-+    }
-+
-+    public int createType(final ProfileType type, final String name) {
-+        synchronized (this) {
-+            final int id = this.totalEntries;
-+
-+            final ProfilerEntry ret = new ProfilerEntry(type, name, id);
-+
-+            final ProfilerEntry prev = this.nameToEntry.putIfAbsent(name, ret);
-+
-+            if (prev != null) {
-+                throw new IllegalStateException("Entry already exists: " + prev);
-+            }
-+
-+            ++this.totalEntries;
-+
-+            ProfilerEntry[] entries = this.typesById;
-+
-+            if (id >= entries.length) {
-+                this.typesById = entries = Arrays.copyOf(entries, entries.length * 2);
-+            }
-+
-+            // should be opaque, but I don't think that matters here.
-+            entries[id] = ret;
-+
-+            return id;
-+        }
-+    }
-+
-+    public static enum ProfileType {
-+        COUNTER, TIMER;
-+    }
-+
-+    public static record ProfilerEntry(ProfileType type, String name, int id) {}
-+}
-diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java b/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..24d041db762f82c16a735271dd4266b8630666ca
---- /dev/null
-+++ b/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java
-@@ -0,0 +1,313 @@
-+package ca.spottedleaf.leafprofiler;
-+
-+import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
-+import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue;
-+import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
-+import java.text.DecimalFormat;
-+import java.util.ArrayDeque;
-+import java.util.ArrayList;
-+import java.util.Arrays;
-+import java.util.List;
-+
-+public final class LeafProfiler {
-+
-+    private static final ThreadLocal<DecimalFormat> THREE_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
-+        return new DecimalFormat("#,##0.000");
-+    });
-+    private static final ThreadLocal<DecimalFormat> NO_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
-+        return new DecimalFormat("#,##0");
-+    });
-+
-+    public final LProfilerRegistry registry;
-+    private final LProfileGraph graph;
-+
-+    private long[] timers = new long[16];
-+    private long[] counters = new long[16];
-+    private final IntArrayFIFOQueue callStack = new IntArrayFIFOQueue();
-+    private int topOfStack = LProfileGraph.ROOT_NODE;
-+    private final LongArrayFIFOQueue timerStack = new LongArrayFIFOQueue();
-+    private long lastTimerStart = 0L;
-+
-+    public LeafProfiler(final LProfilerRegistry registry, final LProfileGraph graph) {
-+        this.registry = registry;
-+        this.graph = graph;
-+    }
-+
-+    private long[] resizeTimers(final long[] old, final int least) {
-+        return this.timers = Arrays.copyOf(old, Math.max(old.length * 2, least * 2));
-+    }
-+
-+    private void incrementTimersDirect(final int nodeId, final long count) {
-+        final long[] timers = this.timers;
-+        if (nodeId >= timers.length) {
-+            this.resizeTimers(timers, nodeId)[nodeId] += count;
-+        } else {
-+            timers[nodeId] += count;
-+        }
-+    }
-+
-+    private long[] resizeCounters(final long[] old, final int least) {
-+        return this.counters = Arrays.copyOf(old, Math.max(old.length * 2, least * 2));
-+    }
-+
-+    private void incrementCountersDirect(final int nodeId, final long count) {
-+        final long[] counters = this.counters;
-+        if (nodeId >= counters.length) {
-+            this.resizeTimers(counters, nodeId)[nodeId] += count;
-+        } else {
-+            counters[nodeId] += count;
-+        }
-+    }
-+
-+    public void incrementCounter(final int timerId, final long count) {
-+        final int node = this.graph.getOrCreateNode(this.topOfStack, timerId);
-+        this.incrementCountersDirect(node, count);
-+    }
-+
-+    public void incrementTimer(final int timerId, final long count) {
-+        final int node = this.graph.getOrCreateNode(this.topOfStack, timerId);
-+        this.incrementTimersDirect(node, count);
-+    }
-+
-+    public void startTimer(final int timerId, final long startTime) {
-+        final long lastTimerStart = this.lastTimerStart;
-+        final LProfileGraph graph = this.graph;
-+        final int parentNode = this.topOfStack;
-+        final IntArrayFIFOQueue callStack = this.callStack;
-+        final LongArrayFIFOQueue timerStack = this.timerStack;
-+
-+        this.lastTimerStart = startTime;
-+        this.topOfStack = graph.getOrCreateNode(parentNode, timerId);
-+
-+        callStack.enqueue(parentNode);
-+        timerStack.enqueue(lastTimerStart);
-+    }
-+
-+    public void stopTimer(final int timerId, final long endTime) {
-+        final long lastStart = this.lastTimerStart;
-+        final int currentNode = this.topOfStack;
-+        final IntArrayFIFOQueue callStack = this.callStack;
-+        final LongArrayFIFOQueue timerStack = this.timerStack;
-+        this.lastTimerStart = timerStack.dequeueLastLong();
-+        this.topOfStack = callStack.dequeueLastInt();
-+
-+        this.incrementTimersDirect(currentNode, endTime - lastStart);
-+        this.incrementCountersDirect(currentNode, 1L);
-+    }
-+
-+    private static final char[][] INDENT_PATTERNS = new char[][] {
-+        "|---".toCharArray(),
-+        "|+++".toCharArray(),
-+    };
-+
-+    public List<String> dumpToString() {
-+        final List<LProfileGraph.GraphNode> graphDFS = this.graph.getDFS();
-+        final Reference2ReferenceOpenHashMap<LProfileGraph.GraphNode, ProfileNode> nodeMap = new Reference2ReferenceOpenHashMap<>();
-+
-+        final ArrayDeque<ProfileNode> orderedNodes = new ArrayDeque<>();
-+
-+        for (int i = 0, len = graphDFS.size(); i < len; ++i) {
-+            final LProfileGraph.GraphNode graphNode = graphDFS.get(i);
-+            final ProfileNode parent = nodeMap.get(graphNode.parent());
-+            final int nodeId = graphNode.nodeId();
-+
-+            final long totalTime = this.timers[nodeId];
-+            final long totalCount = this.counters[nodeId];
-+            final LProfilerRegistry.ProfilerEntry profiler = this.registry.getById(graphNode.timerId());
-+
-+            final ProfileNode profileNode = new ProfileNode(parent, nodeId, profiler, totalTime, totalCount);
-+
-+            if (parent != null) {
-+                parent.childrenTimingCount += totalTime;
-+                parent.children.add(profileNode);
-+            } else if (i != 0) { // i == 0 is root
-+                throw new IllegalStateException("Node " + nodeId + " must have parent");
-+            } else {
-+                // set up
-+                orderedNodes.add(profileNode);
-+            }
-+
-+            nodeMap.put(graphNode, profileNode);
-+        }
-+
-+        final List<String> ret = new ArrayList<>();
-+
-+        long totalTime = 0L;
-+
-+        // totalTime = sum of times for root node's children
-+        for (final ProfileNode node : orderedNodes.peekFirst().children) {
-+            totalTime += node.totalTime;
-+        }
-+
-+        ProfileNode profileNode;
-+        final StringBuilder builder = new StringBuilder();
-+        while ((profileNode = orderedNodes.pollFirst()) != null) {
-+            if (profileNode.nodeId != LProfileGraph.ROOT_NODE && profileNode.totalCount == 0L) {
-+                // skip nodes not recorded
-+                continue;
-+            }
-+
-+            final int depth = profileNode.depth;
-+            profileNode.children.sort((final ProfileNode p1, final ProfileNode p2) -> {
-+                final int typeCompare = p1.profiler.type().compareTo(p2.profiler.type());
-+                if (typeCompare != 0) {
-+                    // first count, then profiler
-+                    return typeCompare;
-+                }
-+
-+                if (p1.profiler.type() == LProfilerRegistry.ProfileType.COUNTER) {
-+                    // highest count first
-+                    return Long.compare(p2.totalCount, p1.totalCount);
-+                } else {
-+                    // highest time first
-+                    return Long.compare(p2.totalTime, p1.totalTime);
-+                }
-+            });
-+
-+            for (int i = profileNode.children.size() - 1; i >= 0; --i) {
-+                final ProfileNode child = profileNode.children.get(i);
-+                child.depth = depth + 1;
-+                orderedNodes.addFirst(child);
-+            }
-+
-+            if (profileNode.nodeId == LProfileGraph.ROOT_NODE) {
-+                // don't display root
-+                continue;
-+            }
-+
-+            final boolean noParent = profileNode.parent == null || profileNode.parent.nodeId == LProfileGraph.ROOT_NODE;
-+
-+            final long parentTime = noParent ? totalTime : profileNode.parent.totalTime;
-+            final LProfilerRegistry.ProfilerEntry profilerEntry = profileNode.profiler;
-+
-+            // format:
-+            // For profiler type:
-+            // <indent><name> X% of total, Y% of parent, self A% of total, self B% of children, Dms raw sum
-+            // For counter type:
-+            // <indent>#<name> avg X sum Y
-+            builder.setLength(0);
-+            // prepare indent
-+            final char[] indent = INDENT_PATTERNS[ret.size() % INDENT_PATTERNS.length];
-+            for (int i = 0; i < depth; ++i) {
-+                builder.append(indent);
-+            }
-+
-+            switch (profilerEntry.type()) {
-+                case TIMER: {
-+                    ret.add(
-+                        builder
-+                            .append(profilerEntry.name())
-+                            .append(' ')
-+                            .append(THREE_DECIMAL_PLACES.get().format(((double)profileNode.totalTime / (double)totalTime) * 100.0))
-+                            .append("% of total, ")
-+                            .append(THREE_DECIMAL_PLACES.get().format(((double)profileNode.totalTime / (double)parentTime) * 100.0))
-+                            .append("% of parent, self ")
-+                            .append(THREE_DECIMAL_PLACES.get().format(((double)(profileNode.totalTime - profileNode.childrenTimingCount) / (double)totalTime) * 100.0))
-+                            .append("% of total, self ")
-+                            .append(THREE_DECIMAL_PLACES.get().format(((double)(profileNode.totalTime - profileNode.childrenTimingCount) / (double)profileNode.totalTime) * 100.0))
-+                            .append("% of children, ")
-+                            .append(THREE_DECIMAL_PLACES.get().format((double)profileNode.totalTime / 1.0E6))
-+                            .append("ms raw sum")
-+                            .toString()
-+                    );
-+                    break;
-+                }
-+                case COUNTER: {
-+                    ret.add(
-+                        builder
-+                            .append('#')
-+                            .append(profilerEntry.name())
-+                            .append(" avg ")
-+                            .append(THREE_DECIMAL_PLACES.get().format((double)profileNode.totalCount / (double)(noParent ? 1L : profileNode.parent.totalCount)))
-+                            .append(" sum ")
-+                            .append(NO_DECIMAL_PLACES.get().format(profileNode.totalCount))
-+                            .toString()
-+                    );
-+                    break;
-+                }
-+                default: {
-+                    throw new IllegalStateException("Unknown type " + profilerEntry.type());
-+                }
-+            }
-+        }
-+
-+        return ret;
-+    }
-+
-+    private static final class ProfileNode {
-+
-+        public final ProfileNode parent;
-+        public final int nodeId;
-+        public final LProfilerRegistry.ProfilerEntry profiler;
-+        public final long totalTime;
-+        public final long totalCount;
-+        public final List<ProfileNode> children = new ArrayList<>();
-+        public long childrenTimingCount;
-+        public int depth = -1;
-+
-+        private ProfileNode(final ProfileNode parent, final int nodeId, final LProfilerRegistry.ProfilerEntry profiler,
-+                            final long totalTime, final long totalCount) {
-+            this.parent = parent;
-+            this.nodeId = nodeId;
-+            this.profiler = profiler;
-+            this.totalTime = totalTime;
-+            this.totalCount = totalCount;
-+        }
-+    }
-+
-+    /*
-+    public static void main(final String[] args) throws Throwable {
-+        final Thread timerHack = new Thread("Timer hack thread") {
-+            @Override
-+            public void run() {
-+                for (;;) {
-+                    try {
-+                        Thread.sleep(Long.MAX_VALUE);
-+                    } catch (final InterruptedException ex) {
-+                        continue;
-+                    }
-+                }
-+            }
-+        };
-+        timerHack.setDaemon(true);
-+        timerHack.start();
-+
-+        final LProfilerRegistry registry = new LProfilerRegistry();
-+
-+        final int tickId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "tick");
-+        final int entityTickId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "entity tick");
-+        final int getEntitiesId = registry.createType(LProfilerRegistry.ProfileType.COUNTER, "getEntities call");
-+        final int tileEntityId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "tile entity tick");
-+        final int creeperEntityId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "creeper entity tick");
-+        final int furnaceId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "furnace tile entity tick");
-+
-+        final LeafProfiler profiler = new LeafProfiler(registry, new LProfileGraph());
-+
-+        profiler.startTimer(tickId, System.nanoTime());
-+        Thread.sleep(10L);
-+
-+        profiler.startTimer(entityTickId, System.nanoTime());
-+        Thread.sleep(1L);
-+
-+        profiler.startTimer(creeperEntityId, System.nanoTime());
-+        Thread.sleep(15L);
-+        profiler.incrementCounter(getEntitiesId, 50L);
-+        profiler.stopTimer(creeperEntityId, System.nanoTime());
-+
-+        profiler.stopTimer(entityTickId, System.nanoTime());
-+
-+        profiler.startTimer(tileEntityId, System.nanoTime());
-+        Thread.sleep(1L);
-+
-+        profiler.startTimer(furnaceId, System.nanoTime());
-+        Thread.sleep(20L);
-+        profiler.stopTimer(furnaceId, System.nanoTime());
-+
-+        profiler.stopTimer(tileEntityId, System.nanoTime());
-+
-+        profiler.stopTimer(tickId, System.nanoTime());
-+
-+        System.out.println("Done.");
-+    }
-+     */
-+}
 diff --git a/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java b/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java
 index 22a2547810d0c029f29685faddf7ac21cde2df0b..e36b4053eb2676e934b8c9c401bf58cfa7dd969c 100644
 --- a/src/main/java/com/destroystokyo/paper/util/RedstoneWireTurbo.java
@@ -5557,10 +5078,10 @@ index 0000000000000000000000000000000000000000..7b31c4ea6d01f936271bdadc3626201d
 +}
 diff --git a/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java b/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea882887d85f
+index 0000000000000000000000000000000000000000..531aa50f2c84e13358e8918bb0c15ea3cd036cb5
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java
-@@ -0,0 +1,1328 @@
+@@ -0,0 +1,1405 @@
 +package io.papermc.paper.threadedregions;
 +
 +import ca.spottedleaf.concurrentutil.map.SWMRLong2ObjectHashTable;
@@ -5583,6 +5104,7 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +import java.util.Arrays;
 +import java.util.Iterator;
 +import java.util.List;
++import java.util.Set;
 +import java.util.concurrent.atomic.AtomicLong;
 +import java.util.concurrent.locks.StampedLock;
 +import java.util.function.BooleanSupplier;
@@ -5761,6 +5283,34 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +        this.regionsById.forEachValue(consumer);
 +    }
 +
++    public int computeForRegions(final int fromChunkX, final int fromChunkZ, final int toChunkX, final int toChunkZ,
++                                  final Consumer<Set<ThreadedRegion<R, S>>> consumer) {
++        final int shift = this.sectionChunkShift;
++        final int fromSectionX = fromChunkX >> shift;
++        final int fromSectionZ = fromChunkZ >> shift;
++        final int toSectionX = toChunkX >> shift;
++        final int toSectionZ = toChunkZ >> shift;
++        this.acquireWriteLock();
++        try {
++            final ReferenceOpenHashSet<ThreadedRegion<R, S>> set = new ReferenceOpenHashSet<>();
++
++            for (int currZ = fromSectionZ; currZ <= toSectionZ; ++currZ) {
++                for (int currX = fromSectionX; currX <= toSectionX; ++currX) {
++                    final ThreadedRegionSection<R, S> section = this.sections.get(CoordinateUtils.getChunkKey(currX, currZ));
++                    if (section != null) {
++                        set.add(section.getRegionPlain());
++                    }
++                }
++            }
++
++            consumer.accept(set);
++
++            return set.size();
++        } finally {
++            this.releaseWriteLock();
++        }
++    }
++
 +    public ThreadedRegion<R, S> getRegionAtUnsynchronised(final int chunkX, final int chunkZ) {
 +        final int sectionX = chunkX >> this.sectionChunkShift;
 +        final int sectionZ = chunkZ >> this.sectionChunkShift;
@@ -5941,12 +5491,10 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +                    if (region == regionOfInterest) {
 +                        continue;
 +                    }
-+                    // need the relaxed check, as the region may already be
-+                    // a merge target
-+                    if (!region.tryKill()) {
++
++                    if (!region.killAndMergeInto(regionOfInterest)) {
++                        // note: the region may already be a merge target
 +                        regionOfInterest.mergeIntoLater(region);
-+                    } else {
-+                        region.mergeInto(regionOfInterest);
 +                    }
 +                }
 +
@@ -6044,10 +5592,9 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +            // merge the regions into this one
 +            final ReferenceOpenHashSet<ThreadedRegion<R, S>> expectingMergeFrom = region.expectingMergeFrom.clone();
 +            for (final ThreadedRegion<R, S> mergeFrom : expectingMergeFrom) {
-+                if (!mergeFrom.tryKill()) {
++                if (!mergeFrom.killAndMergeInto(region)) {
 +                    throw new IllegalStateException("Merge from region " + mergeFrom + " should be killable! Trying to merge into " + region);
 +                }
-+                mergeFrom.mergeInto(region);
 +            }
 +
 +            if (!region.expectingMergeFrom.isEmpty()) {
@@ -6165,17 +5712,24 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +            return;
 +        }
 +
++        final List<ThreadedRegion<R, S>> newRegionObjects = new ArrayList<>(newRegions.size());
++        for (int i = 0, len = newRegions.size(); i < len; ++i) {
++            newRegionObjects.add(new ThreadedRegion<>(this));
++        }
++
++        this.callbacks.preSplit(region, newRegionObjects);
++
 +        // need to split the region, so we need to kill the old one first
 +        region.state = ThreadedRegion.STATE_DEAD;
 +        region.onRemove(true);
 +
 +        // create new regions
 +        final Long2ReferenceOpenHashMap<ThreadedRegion<R, S>> newRegionsMap = new Long2ReferenceOpenHashMap<>();
-+        final ReferenceOpenHashSet<ThreadedRegion<R, S>> newRegionsSet = new ReferenceOpenHashSet<>();
++        final ReferenceOpenHashSet<ThreadedRegion<R, S>> newRegionsSet = new ReferenceOpenHashSet<>(newRegionObjects);
 +
-+        for (final List<ThreadedRegionSection<R, S>> sections : newRegions) {
-+            final ThreadedRegion<R, S> newRegion = new ThreadedRegion<>(this);
-+            newRegionsSet.add(newRegion);
++        for (int i = 0, len = newRegions.size(); i < len; i++) {
++            final List<ThreadedRegionSection<R, S>> sections = newRegions.get(i);
++            final ThreadedRegion<R, S> newRegion = newRegionObjects.get(i);
 +
 +            for (final ThreadedRegionSection<R, S> section : sections) {
 +                section.setRegionRelease(null);
@@ -6359,6 +5913,20 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +            }
 +        }
 +
++        boolean killAndMergeInto(final ThreadedRegion<R, S> mergeTarget) {
++            if (this.state == STATE_TICKING) {
++                return false;
++            }
++
++            this.regioniser.callbacks.preMerge(this, mergeTarget);
++
++            this.tryKill();
++
++            this.mergeInto(mergeTarget);
++
++            return true;
++        }
++
 +        private void mergeInto(final ThreadedRegion<R, S> mergeTarget) {
 +            if (this == mergeTarget) {
 +                throw new IllegalStateException("Cannot merge a region onto itself");
@@ -6887,6 +6455,36 @@ index 0000000000000000000000000000000000000000..72a2b81a0a4dc6aab02d0dbad713ea88
 +         * @param region The region that is now inactive.
 +         */
 +        public void onRegionInactive(final ThreadedRegion<R, S> region);
++
++        /**
++         * Callback for when a region (from) is about to be merged into a target region (into). Note that
++         * {@code from} is still alive and is a distinct region.
++         * <p>
++         * <b>Note:</b>
++         * </p>
++         * <p>
++         * This function is always called while holding critical locks and as such should not attempt to block on anything, and
++         * should NOT retrieve or modify ANY world state.
++         * </p>
++         * @param from The region that will be merged into the target.
++         * @param into The target of the merge.
++         */
++        public void preMerge(final ThreadedRegion<R, S> from, final ThreadedRegion<R, S> into);
++
++        /**
++         * Callback for when a region (from) is about to be split into a list of target region (into). Note that
++         * {@code from} is still alive, while the list of target regions are not initialised.
++         * <p>
++         * <b>Note:</b>
++         * </p>
++         * <p>
++         * This function is always called while holding critical locks and as such should not attempt to block on anything, and
++         * should NOT retrieve or modify ANY world state.
++         * </p>
++         * @param from The region that will be merged into the target.
++         * @param into The list of regions to split into.
++         */
++        public void preSplit(final ThreadedRegion<R, S> from, final List<ThreadedRegion<R, S>> into);
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/threadedregions/TickData.java b/src/main/java/io/papermc/paper/threadedregions/TickData.java
@@ -7230,7 +6828,7 @@ index 0000000000000000000000000000000000000000..29f9fed5f02530b3256e6b993e607d46
 +}
 diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1ea7cd670
+index 0000000000000000000000000000000000000000..150610d7bf25416dbbde7f003c47da562acc68ba
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
 @@ -0,0 +1,565 @@
@@ -7551,10 +7149,6 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +                // don't release region for another tick
 +                return null;
 +            } finally {
-+                TickRegionScheduler.setTickTask(null);
-+                if (this.region != null) {
-+                    TickRegionScheduler.setTickingRegion(null);
-+                }
 +                final long tickEnd = System.nanoTime();
 +                final long cpuEnd = MEASURE_CPU_TIME ? THREAD_MX_BEAN.getCurrentThreadCpuTime() : 0L;
 +
@@ -7564,6 +7158,10 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +                );
 +
 +                this.addTickTime(time);
++                TickRegionScheduler.setTickTask(null);
++                if (this.region != null) {
++                    TickRegionScheduler.setTickingRegion(null);
++                }
 +            }
 +
 +            return !this.markNotTicking() || this.cancelled.get() ? null : Boolean.valueOf(ret);
@@ -7627,10 +7225,6 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +                // regionFailed will schedule a shutdown, so we should avoid letting this region tick further
 +                return false;
 +            } finally {
-+                TickRegionScheduler.setTickTask(null);
-+                if (this.region != null) {
-+                    TickRegionScheduler.setTickingRegion(null);
-+                }
 +                final long tickEnd = System.nanoTime();
 +                final long cpuEnd = MEASURE_CPU_TIME ? THREAD_MX_BEAN.getCurrentThreadCpuTime() : 0L;
 +
@@ -7645,6 +7239,10 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +                );
 +
 +                this.addTickTime(time);
++                TickRegionScheduler.setTickTask(null);
++                if (this.region != null) {
++                    TickRegionScheduler.setTickingRegion(null);
++                }
 +            }
 +
 +            // Only AFTER updating the tickStart
@@ -7654,7 +7252,7 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +        /**
 +         * Only safe to call if this tick data matches the current ticking region.
 +         */
-+        private void addTickTime(final TickTime time) {
++        protected void addTickTime(final TickTime time) {
 +            synchronized (this) {
 +                this.currentTickData = null;
 +                this.currentTickingThread = null;
@@ -7800,10 +7398,10 @@ index 0000000000000000000000000000000000000000..ee9f5e1f3387998cddbeb1dc6dc6e2b1
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
-index d5d39e9c1f326e91010237b0db80d527ac52f4d6..6c76c70574642aa4f3a8fce74e4608781ce132ec 100644
+index d5d39e9c1f326e91010237b0db80d527ac52f4d6..902e82854c89779c7e23c63d1be5b04dad2a61e3 100644
 --- a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
 +++ b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
-@@ -1,9 +1,392 @@
+@@ -1,9 +1,404 @@
  package io.papermc.paper.threadedregions;
  
 -// placeholder class for Folia
@@ -7903,6 +7501,18 @@ index d5d39e9c1f326e91010237b0db80d527ac52f4d6..6c76c70574642aa4f3a8fce74e460878
 +        data.tickHandle = data.tickHandle.copy();
 +    }
 +
++    @Override
++    public void preMerge(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> from,
++                         final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> into) {
++
++    }
++
++    @Override
++    public void preSplit(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> from,
++                         final java.util.List<ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData>> into) {
++
++    }
++
 +    public static final class TickRegionSectionData implements ThreadedRegionizer.ThreadedRegionSectionData {}
 +
 +    public static final class RegionStats {
diff --git a/patches/server/0019-Region-profiler.patch b/patches/server/0019-Region-profiler.patch
new file mode 100644
index 0000000..cf47b8e
--- /dev/null
+++ b/patches/server/0019-Region-profiler.patch
@@ -0,0 +1,1958 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Tue, 3 Oct 2023 06:03:34 -0700
+Subject: [PATCH] Region profiler
+
+Profiling for a region starts with the /profiler command.
+The usage for /profiler:
+/profiler <world> <block x> <block z> <time in s> [radius, default 100 blocks]
+
+Any region within the radius of the specified block coordinates
+will be profiled. The profiling will stop after the specified
+time has passed.
+
+Once the profiler finishes, it will place a report in
+the directory ./profiler/<id>.
+
+Since regions can split into smaller regions, or merge into
+other regions, the profiler will track this information. If
+a profiled region splits, then all of the regions it splits
+into are attached to the same profiler instance. If a profiled
+region merges into another region, then the merged region is
+profiled. This information is tracked and logged into the
+"journal.txt" file contained in the report directory. The
+journal tracks the region ids for the merge/split operations.
+
+Region profiling is placed into the "region-X.txt" file where
+X is the region id inside the profile directory. The header
+of the file describes some stats about the region, namely
+total profiling duration, ticks, utilisation, TPS, and MSPT.
+
+Then, the timing tree is follows. The format is as specified:
+
+There are two types of data recorded: Timers and Counters.
+
+Timers are specified as follows:
+<indent><name> X% total, Y% parent, self A% total, self B% children, avg D sum E, Fms raw sum
+The above specifies the format for a named timer.
+
+The <indent> specifies the number of parent timers.
+
+"X" represents the percentage of time the timer took relative
+to the entire profiling instance.
+
+"Y" represents the percentage of time the timer took relative
+to its _parents_ timer. For example:
+```
+Full Tick 100.000% total, 100.000% parent, self 0.889% total, self 0.889% children, avg 200.000 sum 200, 401.300ms raw sum
+|+++Tick World: minecraft:overworld 81.409% total, 81.409% parent, self 1.873% total, self 2.301% children, avg 1.000 sum 200, 326.694ms raw sum
+|---|---Entity Tick 56.784% total, 69.751% parent, self 6.049% total, self 10.652% children, avg 1.000 sum 200, 227.874ms raw sum
+```
+"Entity Tick" measured 69.751% of the time for the "Tick World: minecraft:overworld" timer.
+
+"A" represents the self time relative to the entire profiling instance.
+The self time is the amount of time for a timer that is _not_ measured
+by a child timer.
+
+"B" represents the self time relative to its _parents_ timer.
+
+"D" represents the average number of times the timer is invoked relative to
+its parent.
+For example:
+```
+|---|---|---Entity Tick: bat 2.642% total, 7.343% parent, self 2.642% total, self 100.000% children, avg 14.975 sum 2,995, 23.127ms raw sum
+```
+In this case, an average of 14.975 bats were ticked for every
+time the "Entity Tick" timer was invoked.
+
+"E" represents the total number of times the timer is invoked.
+
+"F" represents the total raw time accumulated by the timer.
+
+Counters are specified as follows:
+<indent>#<name> avg X sum Y
+
+The X is the average number of times the counter is invoked
+relative to the parent, exactly similar to the D field of Timers,
+where Y is the total number of times the counter is invoked.
+
+diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java b/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..19c13bd372711bce978a463f85130f1e10202da9
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/leafprofiler/LProfileGraph.java
+@@ -0,0 +1,106 @@
++package ca.spottedleaf.leafprofiler;
++
++import it.unimi.dsi.fastutil.ints.Int2IntMap;
++import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
++import java.util.ArrayDeque;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.Iterator;
++import java.util.List;
++
++public final class LProfileGraph {
++
++    public static final int ROOT_NODE = 0;
++    // Array idx is the graph node id, where the int->int mapping is a mapping of profile timer id to graph node id
++    private Int2IntOpenHashMap[] nodes;
++    private int nodeCount;
++
++    public LProfileGraph() {
++        final Int2IntOpenHashMap[] nodes = new Int2IntOpenHashMap[16];
++        nodes[ROOT_NODE] = new Int2IntOpenHashMap();
++
++        this.nodes = nodes;
++        this.nodeCount = 1;
++    }
++
++    public static record GraphNode(GraphNode parent, int nodeId, int timerId) {}
++
++    public List<GraphNode> getDFS() {
++        final List<GraphNode> ret = new ArrayList<>();
++        final ArrayDeque<GraphNode> queue = new ArrayDeque<>();
++
++        queue.addFirst(new GraphNode(null, ROOT_NODE, -1));
++        final Int2IntOpenHashMap[] nodes = this.nodes;
++
++        GraphNode graphNode;
++        while ((graphNode = queue.pollFirst()) != null) {
++            ret.add(graphNode);
++
++            final int parent = graphNode.nodeId;
++
++            final Int2IntOpenHashMap children = nodes[parent];
++
++            for (final Iterator<Int2IntMap.Entry> iterator = children.int2IntEntrySet().fastIterator(); iterator.hasNext();) {
++                final Int2IntMap.Entry entry = iterator.next();
++                queue.addFirst(new GraphNode(graphNode, entry.getIntValue(), entry.getIntKey()));
++            }
++        }
++
++        return ret;
++    }
++
++    private int createNode(final int parent, final int timerId) {
++        Int2IntOpenHashMap[] nodes = this.nodes;
++
++        final Int2IntOpenHashMap node = nodes[parent];
++
++        final int newNode = this.nodeCount;
++        final int prev = node.putIfAbsent(timerId, newNode);
++
++        if (prev != 0) {
++            // already exists
++            return prev;
++        }
++
++        // insert new node
++        ++this.nodeCount;
++
++        if (newNode >= nodes.length) {
++            this.nodes = (nodes = Arrays.copyOf(nodes, nodes.length * 2));
++        }
++
++        nodes[newNode] = new Int2IntOpenHashMap();
++
++        return newNode;
++    }
++
++    public int getNode(final int parent, final int timerId) {
++        // note: requires parent node to exist
++        final Int2IntOpenHashMap[] nodes = this.nodes;
++
++        if (parent >= nodes.length) {
++            return -1;
++        }
++
++        final int mapping = nodes[parent].get(timerId);
++
++        if (mapping != 0) {
++            return mapping;
++        }
++
++        return -1;
++    }
++
++    public int getOrCreateNode(final int parent, final int timerId) {
++        // note: requires parent node to exist
++        final Int2IntOpenHashMap[] nodes = this.nodes;
++
++        final int mapping = nodes[parent].get(timerId);
++
++        if (mapping != 0) {
++            return mapping;
++        }
++
++        return this.createNode(parent, timerId);
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java b/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4602fb26621040e25ac71fb4670b1784e084f85b
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/leafprofiler/LProfilerRegistry.java
+@@ -0,0 +1,117 @@
++package ca.spottedleaf.leafprofiler;
++
++import java.util.Arrays;
++import java.util.concurrent.ConcurrentHashMap;
++
++public final class LProfilerRegistry {
++
++    // volatile required to ensure correct publishing when resizing
++    private volatile ProfilerEntry[] typesById = new ProfilerEntry[16];
++    private int totalEntries;
++    private final ConcurrentHashMap<String, ProfilerEntry> nameToEntry = new ConcurrentHashMap<>();
++
++    public LProfilerRegistry() {}
++
++    public ProfilerEntry getById(final int id) {
++        final ProfilerEntry[] entries = this.typesById;
++
++        return id < 0 || id >= entries.length ? null : entries[id];
++    }
++
++    public ProfilerEntry getByName(final String name) {
++        return this.nameToEntry.get(name);
++    }
++
++    public int getOrCreateType(final ProfileType type, final String name) {
++        ProfilerEntry entry = this.nameToEntry.get(name);
++        if (entry != null) {
++            return entry.id;
++        }
++        synchronized (this) {
++            entry = this.nameToEntry.get(name);
++            if (entry != null) {
++                return entry.id;
++            }
++            return this.createType(type, name);
++        }
++    }
++
++    public int getOrCreateTimer(final String name) {
++        return this.getOrCreateType(ProfileType.TIMER, name);
++    }
++
++    public int getOrCreateCounter(final String name) {
++        return this.getOrCreateType(ProfileType.COUNTER, name);
++    }
++
++    public int createType(final ProfileType type, final String name) {
++        synchronized (this) {
++            final int id = this.totalEntries;
++
++            final ProfilerEntry ret = new ProfilerEntry(type, name, id);
++
++            final ProfilerEntry prev = this.nameToEntry.putIfAbsent(name, ret);
++
++            if (prev != null) {
++                throw new IllegalStateException("Entry already exists: " + prev);
++            }
++
++            ++this.totalEntries;
++
++            ProfilerEntry[] entries = this.typesById;
++
++            if (id >= entries.length) {
++                this.typesById = entries = Arrays.copyOf(entries, entries.length * 2);
++            }
++
++            // should be opaque, but I don't think that matters here.
++            entries[id] = ret;
++
++            return id;
++        }
++    }
++
++    public static enum ProfileType {
++        COUNTER, TIMER;
++    }
++
++    public static record ProfilerEntry(ProfileType type, String name, int id) {}
++
++    public static final LProfilerRegistry GLOBAL_REGISTRY = new LProfilerRegistry();
++    public static final int TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Full Tick");
++    public static final int IN_BETWEEN_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "In Between Tick");
++    public static final int INTERNAL_TICK_TASKS = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Internal Tick Tasks");
++    public static final int PLUGIN_TICK_TASKS = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Plugin Tick Tasks");
++    public static final int ENTITY_SCHEDULER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Entity Scheduler Tick");
++    public static final int ENTITY_SCHEDULERS_TICKED = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Entity Schedulers Ticked");
++    public static final int CONNECTION_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Connection Tick");
++    public static final int AUTOSAVE = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Autosave");
++    public static final int PLAYER_SAVE = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Player Save");
++    public static final int CHUNK_SAVE = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Chunk Save");
++    public static final int BLOCK_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Block Tick");
++    public static final int FLUID_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Fluid Tick");
++    public static final int BLOCK_OR_FLUID_TICK_COUNT = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Block/Fluid Tick Count");
++    public static final int RAIDS_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Raids Tick");
++    public static final int CHUNK_PROVIDER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Chunk Source Tick");
++    public static final int CHUNK_HOLDER_MANAGER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Chunk Holder Manager Tick");
++    public static final int TICKET_LEVEL_UPDATE_PROCESSING = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Ticket Level Update Processing");
++    public static final int PLAYER_CHUNK_LOADER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Player Chunk Loader Tick");
++    public static final int CHUNK_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Chunk Ticks");
++    public static final int MOB_SPAWN_ENTITY_COUNT = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Mob Spawn Entity Count");
++    public static final int SPAWN_AND_RANDOM_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Spawn Entities And Random Tick");
++    public static final int SPAWN_CHUNK_COUNT = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Entity Spawn Chunk Count");
++    public static final int RANDOM_CHUNK_TICK_COUNT = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Random Chunk Tick Count");
++    public static final int MISC_MOB_SPAWN_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Misc Mob Spawn Tick");
++    public static final int BROADCAST_BLOCK_CHANGES = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Broadcast Block Changes");
++    public static final int ENTITY_TRACKER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Entity Tracker Tick");
++    public static final int TRACKED_UNLOADED_ENTITY_COUNTS = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Total Untracked Unloaded Entities");
++    public static final int TRACKED_ENTITY_COUNTS = GLOBAL_REGISTRY.createType(ProfileType.COUNTER, "Total Tracked Entities");
++    public static final int POI_MANAGER_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "POI Manager Tick");
++    public static final int PROCESS_UNLOADS = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Process Unloads");
++    public static final int BLOCK_EVENT_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Block Event Tick");
++    public static final int ENTITY_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Entity Tick");
++    public static final int DRAGON_FIGHT_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Dragon Fight Tick");
++    public static final int TILE_ENTITY = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Tile Entities");
++    public static final int TILE_ENTITY_PENDING = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Tile Entity Handle Pending");
++    public static final int TILE_ENTITY_TICK = GLOBAL_REGISTRY.createType(ProfileType.TIMER, "Tile Entity Tick");
++}
+diff --git a/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java b/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6c6e759fccce3b669490c09933c01705107d24ac
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/leafprofiler/LeafProfiler.java
+@@ -0,0 +1,326 @@
++package ca.spottedleaf.leafprofiler;
++
++import com.mojang.logging.LogUtils;
++import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
++import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue;
++import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
++import org.slf4j.Logger;
++import java.text.DecimalFormat;
++import java.util.ArrayDeque;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.List;
++
++public final class LeafProfiler {
++
++    private static final Logger LOGGER = LogUtils.getLogger();
++
++    private static final ThreadLocal<DecimalFormat> THREE_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0.000");
++    });
++    private static final ThreadLocal<DecimalFormat> NO_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0");
++    });
++
++    public final LProfilerRegistry registry;
++    private final LProfileGraph graph;
++
++    private long[] timers = new long[16];
++    private long[] counters = new long[16];
++    private final IntArrayFIFOQueue callStack = new IntArrayFIFOQueue();
++    private int topOfStack = LProfileGraph.ROOT_NODE;
++    private final LongArrayFIFOQueue timerStack = new LongArrayFIFOQueue();
++    private long lastTimerStart = 0L;
++
++    public LeafProfiler(final LProfilerRegistry registry, final LProfileGraph graph) {
++        this.registry = registry;
++        this.graph = graph;
++    }
++
++    private long[] resizeTimers(final long[] old, final int least) {
++        return this.timers = Arrays.copyOf(old, Math.max(old.length * 2, least * 2));
++    }
++
++    private void incrementTimersDirect(final int nodeId, final long count) {
++        final long[] timers = this.timers;
++        if (nodeId >= timers.length) {
++            this.resizeTimers(timers, nodeId)[nodeId] += count;
++        } else {
++            timers[nodeId] += count;
++        }
++    }
++
++    private long[] resizeCounters(final long[] old, final int least) {
++        return this.counters = Arrays.copyOf(old, Math.max(old.length * 2, least * 2));
++    }
++
++    private void incrementCountersDirect(final int nodeId, final long count) {
++        final long[] counters = this.counters;
++        if (nodeId >= counters.length) {
++            this.resizeCounters(counters, nodeId)[nodeId] += count;
++        } else {
++            counters[nodeId] += count;
++        }
++    }
++
++    public void incrementCounter(final int timerId, final long count) {
++        final int node = this.graph.getOrCreateNode(this.topOfStack, timerId);
++        this.incrementCountersDirect(node, count);
++    }
++
++    public void incrementTimer(final int timerId, final long count) {
++        final int node = this.graph.getOrCreateNode(this.topOfStack, timerId);
++        this.incrementTimersDirect(node, count);
++    }
++
++    public void startTimer(final int timerId, final long startTime) {
++        final long lastTimerStart = this.lastTimerStart;
++        final LProfileGraph graph = this.graph;
++        final int parentNode = this.topOfStack;
++        final IntArrayFIFOQueue callStack = this.callStack;
++        final LongArrayFIFOQueue timerStack = this.timerStack;
++
++        this.lastTimerStart = startTime;
++        this.topOfStack = graph.getOrCreateNode(parentNode, timerId);
++
++        callStack.enqueue(parentNode);
++        timerStack.enqueue(lastTimerStart);
++    }
++
++    public void stopTimer(final int timerId, final long endTime) {
++        final long lastStart = this.lastTimerStart;
++        final int currentNode = this.topOfStack;
++        final IntArrayFIFOQueue callStack = this.callStack;
++        final LongArrayFIFOQueue timerStack = this.timerStack;
++        this.lastTimerStart = timerStack.dequeueLastLong();
++        this.topOfStack = callStack.dequeueLastInt();
++
++        if (currentNode != this.graph.getNode(this.topOfStack, timerId)) {
++            final LProfilerRegistry.ProfilerEntry timer = this.registry.getById(timerId);
++            throw new IllegalStateException("Timer " + (timer == null ? "null" : timer.name()) + " did not stop");
++        }
++
++        this.incrementTimersDirect(currentNode, endTime - lastStart);
++        this.incrementCountersDirect(currentNode, 1L);
++    }
++
++    private static final char[][] INDENT_PATTERNS = new char[][] {
++        "|---".toCharArray(),
++        "|+++".toCharArray(),
++    };
++
++    public List<String> dumpToString() {
++        final List<LProfileGraph.GraphNode> graphDFS = this.graph.getDFS();
++        final Reference2ReferenceOpenHashMap<LProfileGraph.GraphNode, ProfileNode> nodeMap = new Reference2ReferenceOpenHashMap<>();
++
++        final ArrayDeque<ProfileNode> orderedNodes = new ArrayDeque<>();
++
++        for (int i = 0, len = graphDFS.size(); i < len; ++i) {
++            final LProfileGraph.GraphNode graphNode = graphDFS.get(i);
++            final ProfileNode parent = nodeMap.get(graphNode.parent());
++            final int nodeId = graphNode.nodeId();
++
++            final long totalTime = nodeId >= this.timers.length ? 0L : this.timers[nodeId];
++            final long totalCount = nodeId >= this.counters.length ? 0L : this.counters[nodeId];
++            final LProfilerRegistry.ProfilerEntry profiler = this.registry.getById(graphNode.timerId());
++
++            final ProfileNode profileNode = new ProfileNode(parent, nodeId, profiler, totalTime, totalCount);
++
++            if (parent != null) {
++                parent.childrenTimingCount += totalTime;
++                parent.children.add(profileNode);
++            } else if (i != 0) { // i == 0 is root
++                throw new IllegalStateException("Node " + nodeId + " must have parent");
++            } else {
++                // set up
++                orderedNodes.add(profileNode);
++            }
++
++            nodeMap.put(graphNode, profileNode);
++        }
++
++        final List<String> ret = new ArrayList<>();
++
++        long totalTime = 0L;
++
++        // totalTime = sum of times for root node's children
++        for (final ProfileNode node : orderedNodes.peekFirst().children) {
++            totalTime += node.totalTime;
++        }
++
++        ProfileNode profileNode;
++        final StringBuilder builder = new StringBuilder();
++        while ((profileNode = orderedNodes.pollFirst()) != null) {
++            if (profileNode.nodeId != LProfileGraph.ROOT_NODE && profileNode.totalCount == 0L) {
++                // skip nodes not recorded
++                continue;
++            }
++
++            final int depth = profileNode.depth;
++            profileNode.children.sort((final ProfileNode p1, final ProfileNode p2) -> {
++                final int typeCompare = p1.profiler.type().compareTo(p2.profiler.type());
++                if (typeCompare != 0) {
++                    // first count, then profiler
++                    return typeCompare;
++                }
++
++                if (p1.profiler.type() == LProfilerRegistry.ProfileType.COUNTER) {
++                    // highest count first
++                    return Long.compare(p2.totalCount, p1.totalCount);
++                } else {
++                    // highest time first
++                    return Long.compare(p2.totalTime, p1.totalTime);
++                }
++            });
++
++            for (int i = profileNode.children.size() - 1; i >= 0; --i) {
++                final ProfileNode child = profileNode.children.get(i);
++                child.depth = depth + 1;
++                orderedNodes.addFirst(child);
++            }
++
++            if (profileNode.nodeId == LProfileGraph.ROOT_NODE) {
++                // don't display root
++                continue;
++            }
++
++            final boolean noParent = profileNode.parent == null || profileNode.parent.nodeId == LProfileGraph.ROOT_NODE;
++
++            final long parentTime = noParent ? totalTime : profileNode.parent.totalTime;
++            final LProfilerRegistry.ProfilerEntry profilerEntry = profileNode.profiler;
++
++            // format:
++            // For profiler type:
++            // <indent><name> X% total, Y% parent, self A% total, self B% children, avg X sum Y, Dms raw sum
++            // For counter type:
++            // <indent>#<name> avg X sum Y
++            builder.setLength(0);
++            // prepare indent
++            final char[] indent = INDENT_PATTERNS[ret.size() % INDENT_PATTERNS.length];
++            for (int i = 0; i < depth; ++i) {
++                builder.append(indent);
++            }
++
++            switch (profilerEntry.type()) {
++                case TIMER: {
++                    ret.add(
++                        builder
++                            .append(profilerEntry.name())
++                            .append(' ')
++                            .append(THREE_DECIMAL_PLACES.get().format(((double)profileNode.totalTime / (double)totalTime) * 100.0))
++                            .append("% total, ")
++                            .append(THREE_DECIMAL_PLACES.get().format(((double)profileNode.totalTime / (double)parentTime) * 100.0))
++                            .append("% parent, self ")
++                            .append(THREE_DECIMAL_PLACES.get().format(((double)(profileNode.totalTime - profileNode.childrenTimingCount) / (double)totalTime) * 100.0))
++                            .append("% total, self ")
++                            .append(THREE_DECIMAL_PLACES.get().format(((double)(profileNode.totalTime - profileNode.childrenTimingCount) / (double)profileNode.totalTime) * 100.0))
++                            .append("% children, avg ")
++                            .append(THREE_DECIMAL_PLACES.get().format((double)profileNode.totalCount / (double)(noParent ? 1L : profileNode.parent.totalCount)))
++                            .append(" sum ")
++                            .append(NO_DECIMAL_PLACES.get().format(profileNode.totalCount))
++                            .append(", ")
++                            .append(THREE_DECIMAL_PLACES.get().format((double)profileNode.totalTime / 1.0E6))
++                            .append("ms raw sum")
++                            .toString()
++                    );
++                    break;
++                }
++                case COUNTER: {
++                    ret.add(
++                        builder
++                            .append('#')
++                            .append(profilerEntry.name())
++                            .append(" avg ")
++                            .append(THREE_DECIMAL_PLACES.get().format((double)profileNode.totalCount / (double)(noParent ? 1L : profileNode.parent.totalCount)))
++                            .append(" sum ")
++                            .append(NO_DECIMAL_PLACES.get().format(profileNode.totalCount))
++                            .toString()
++                    );
++                    break;
++                }
++                default: {
++                    throw new IllegalStateException("Unknown type " + profilerEntry.type());
++                }
++            }
++        }
++
++        return ret;
++    }
++
++    private static final class ProfileNode {
++
++        public final ProfileNode parent;
++        public final int nodeId;
++        public final LProfilerRegistry.ProfilerEntry profiler;
++        public final long totalTime;
++        public final long totalCount;
++        public final List<ProfileNode> children = new ArrayList<>();
++        public long childrenTimingCount;
++        public int depth = -1;
++
++        private ProfileNode(final ProfileNode parent, final int nodeId, final LProfilerRegistry.ProfilerEntry profiler,
++                            final long totalTime, final long totalCount) {
++            this.parent = parent;
++            this.nodeId = nodeId;
++            this.profiler = profiler;
++            this.totalTime = totalTime;
++            this.totalCount = totalCount;
++        }
++    }
++
++    /*
++    public static void main(final String[] args) throws Throwable {
++        final Thread timerHack = new Thread("Timer hack thread") {
++            @Override
++            public void run() {
++                for (;;) {
++                    try {
++                        Thread.sleep(Long.MAX_VALUE);
++                    } catch (final InterruptedException ex) {
++                        continue;
++                    }
++                }
++            }
++        };
++        timerHack.setDaemon(true);
++        timerHack.start();
++
++        final LProfilerRegistry registry = new LProfilerRegistry();
++
++        final int tickId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "tick");
++        final int entityTickId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "entity tick");
++        final int getEntitiesId = registry.createType(LProfilerRegistry.ProfileType.COUNTER, "getEntities call");
++        final int tileEntityId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "tile entity tick");
++        final int creeperEntityId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "creeper entity tick");
++        final int furnaceId = registry.createType(LProfilerRegistry.ProfileType.TIMER, "furnace tile entity tick");
++
++        final LeafProfiler profiler = new LeafProfiler(registry, new LProfileGraph());
++
++        profiler.startTimer(tickId, System.nanoTime());
++        Thread.sleep(10L);
++
++        profiler.startTimer(entityTickId, System.nanoTime());
++        Thread.sleep(1L);
++
++        profiler.startTimer(creeperEntityId, System.nanoTime());
++        Thread.sleep(15L);
++        profiler.incrementCounter(getEntitiesId, 50L);
++        profiler.stopTimer(creeperEntityId, System.nanoTime());
++
++        profiler.stopTimer(entityTickId, System.nanoTime());
++
++        profiler.startTimer(tileEntityId, System.nanoTime());
++        Thread.sleep(1L);
++
++        profiler.startTimer(furnaceId, System.nanoTime());
++        Thread.sleep(20L);
++        profiler.stopTimer(furnaceId, System.nanoTime());
++
++        profiler.stopTimer(tileEntityId, System.nanoTime());
++
++        profiler.stopTimer(tickId, System.nanoTime());
++
++        System.out.println("Done.");
++    }
++     */
++}
+diff --git a/src/main/java/ca/spottedleaf/leafprofiler/RegionizedProfiler.java b/src/main/java/ca/spottedleaf/leafprofiler/RegionizedProfiler.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..95c0e6416afafbb633f0a30ae22df166055a0cbc
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/leafprofiler/RegionizedProfiler.java
+@@ -0,0 +1,276 @@
++package ca.spottedleaf.leafprofiler;
++
++import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickData;
++import io.papermc.paper.threadedregions.TickRegionScheduler;
++import io.papermc.paper.threadedregions.TickRegions;
++import it.unimi.dsi.fastutil.longs.LongArrayList;
++import java.util.ArrayList;
++import java.util.List;
++import java.util.concurrent.atomic.AtomicInteger;
++import java.util.concurrent.atomic.AtomicLong;
++import java.util.function.Consumer;
++import java.util.function.Supplier;
++
++public final class RegionizedProfiler {
++
++    private static final AtomicLong ID_GENERATOR = new AtomicLong();
++
++    public final long id;
++    private final AtomicInteger profilingRegions = new AtomicInteger();
++    private final MultiThreadedQueue<RecordedOperation> operations = new MultiThreadedQueue<>();
++    private final MultiThreadedQueue<RegionTimings> timings = new MultiThreadedQueue<>();
++    private final long absoluteStart = System.nanoTime();
++    private final long absoluteEnd;
++    private final Consumer<ProfileResults> onFinish;
++
++    public RegionizedProfiler(final long id, final long recordFor, final Consumer<ProfileResults> onFinish) {
++        this.id = id;
++        this.onFinish = onFinish;
++        this.absoluteEnd = this.absoluteStart + recordFor;
++    }
++
++    public void createProfiler(final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> into) {
++        final Handle newProfiler = new Handle(
++            new LeafProfiler(LProfilerRegistry.GLOBAL_REGISTRY, new LProfileGraph()),
++            false, this, into
++        );
++        newProfiler.startProfiler();
++
++        into.getData().profiler = newProfiler;
++    }
++
++    public void preMerge(final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> from,
++                         final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> into) {
++        final Handle fromProfiler = from.getData().profiler;
++        final Handle intoProfiler = into.getData().profiler;
++        this.operations.add(new RecordedOperation(OperationType.MERGE, from.id, LongArrayList.of(into.id), System.nanoTime()));
++
++        if (intoProfiler != null) {
++            // target is already profiling
++            fromProfiler.stopProfiler();
++            return;
++        }
++
++        this.createProfiler(into);
++
++        // the old profiler must be terminated only after creating the new one, so that there is always at least one
++        // profiler running, otherwise the profiler will complete
++        fromProfiler.stopProfiler();
++    }
++
++    public void preSplit(final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> from,
++                         final List<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> into) {
++        final Handle fromProfiler = from.getData().profiler;
++
++        final LongArrayList regions = new LongArrayList(into.size());
++        for (int i = 0, len = into.size(); i < len; ++i) {
++            regions.add(into.get(i).id);
++        }
++
++        this.operations.add(new RecordedOperation(OperationType.SPLIT, from.id, regions, System.nanoTime()));
++
++        for (int i = 0, len = into.size(); i < len; ++i) {
++            // create new profiler
++            this.createProfiler(into.get(i));
++        }
++
++        // the old profiler must be terminated only after creating the new ones, so that there is always at least one
++        // profiler running, otherwise the profiler will complete
++        fromProfiler.stopProfiler();
++    }
++
++    public static record RecordedOperation(
++        OperationType type,
++
++        /*
++         * The target for start,end or the `from` region for merge/split
++         */
++        long regionOfInterest,
++
++        /*
++         * The merge target or the split targets
++         */
++        LongArrayList targetRegions,
++
++        /*
++         * The timestamp for this operation
++         */
++        long time
++    ) {}
++
++    public static enum OperationType {
++        START,
++        MERGE,
++        SPLIT,
++        END;
++    }
++
++    public static final class Handle {
++
++        public final LeafProfiler profiler;
++        private boolean noOp;
++        public final RegionizedProfiler profilerGroup;
++        private final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region;
++        private final TickData tickData = new TickData(Long.MAX_VALUE);
++        private long startTime;
++
++        public static final Handle NO_OP_HANDLE = new Handle(
++            null, true, null, null
++        );
++
++        private Handle(final LeafProfiler profiler, final boolean noOp,
++                       final RegionizedProfiler profilerGroup,
++                       final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region) {
++            this.profiler = profiler;
++            this.noOp = noOp;
++            this.profilerGroup = profilerGroup;
++            this.region = region;
++        }
++
++        public void startTick() {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.startTimer(LProfilerRegistry.TICK, System.nanoTime());
++        }
++
++        public void stopTick() {
++            if (this.noOp) {
++                return;
++            }
++
++
++
++            this.profiler.stopTimer(LProfilerRegistry.TICK, System.nanoTime());
++        }
++
++        public void startInBetweenTick() {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.startTimer(LProfilerRegistry.IN_BETWEEN_TICK, System.nanoTime());
++        }
++
++        public void stopInBetweenTick() {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.stopTimer(LProfilerRegistry.IN_BETWEEN_TICK, System.nanoTime());
++        }
++
++        public void startTimer(final int timerId) {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.startTimer(timerId, System.nanoTime());
++        }
++
++        public void stopTimer(final int timerId) {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.stopTimer(timerId, System.nanoTime());
++        }
++
++        public void addCounter(final int counterId, final long count) {
++            if (this.noOp) {
++                return;
++            }
++
++            this.profiler.incrementCounter(counterId, count);
++        }
++
++        public int getOrCreateTimerAndStart(final Supplier<String> name) {
++            if (this.noOp) {
++                return -1;
++            }
++
++            final int timer = this.profiler.registry.getOrCreateType(LProfilerRegistry.ProfileType.TIMER, name.get());
++
++            this.profiler.startTimer(timer, System.nanoTime());
++
++            return timer;
++        }
++
++        public void addTickTime(final TickRegionScheduler.TickTime tickTime) {
++            if (this.noOp) {
++                return;
++            }
++            this.tickData.addDataFrom(tickTime);
++        }
++
++        public void startProfiler() {
++            if (this.noOp) {
++                return;
++            }
++            this.profilerGroup.profilingRegions.getAndIncrement();
++            this.startTime = System.nanoTime();
++            this.profilerGroup.operations.add(
++                new RecordedOperation(OperationType.START, this.region.id, new LongArrayList(), this.startTime)
++            );
++        }
++
++        public void stopProfiler() {
++            if (this.noOp) {
++                return;
++            }
++
++            final long endTime = System.nanoTime();
++
++            this.noOp = true;
++            this.region.getData().profiler = null;
++            this.profilerGroup.operations.add(
++                new RecordedOperation(OperationType.END, this.region.id, new LongArrayList(), endTime)
++            );
++            this.profilerGroup.timings.add(
++                new RegionTimings(
++                    this.startTime, endTime, this.region.id, this.profiler, this.tickData
++                )
++            );
++
++            if (this.profilerGroup.profilingRegions.decrementAndGet() == 0) {
++                this.profilerGroup.onFinish.accept(
++                    new ProfileResults(
++                        this.profilerGroup.id,
++                        this.profilerGroup.absoluteStart,
++                        endTime,
++                        new ArrayList<>(this.profilerGroup.timings),
++                        new ArrayList<>(this.profilerGroup.operations)
++                    )
++                );
++            }
++        }
++
++        public void checkStop() {
++            if (this.noOp) {
++                return;
++            }
++            if ((System.nanoTime() - this.profilerGroup.absoluteEnd) >= 0L) {
++                this.stopProfiler();
++            }
++        }
++    }
++
++    public static record ProfileResults(
++        long profileId,
++        long startTime,
++        long endTime,
++        List<RegionTimings> timings,
++        List<RecordedOperation> operations
++    ) {}
++
++    public static record RegionTimings(
++        long startTime,
++        long endTime,
++        long regionId,
++        LeafProfiler profiler,
++        TickData tickData
++    ) {}
++}
+diff --git a/src/main/java/io/papermc/paper/chunk/system/scheduling/ChunkHolderManager.java b/src/main/java/io/papermc/paper/chunk/system/scheduling/ChunkHolderManager.java
+index 40411b335e99f67d6a82e70db6e5e4c0372102ec..db4ee79b2345a3be0723416a83251d1c76bf834b 100644
+--- a/src/main/java/io/papermc/paper/chunk/system/scheduling/ChunkHolderManager.java
++++ b/src/main/java/io/papermc/paper/chunk/system/scheduling/ChunkHolderManager.java
+@@ -1470,8 +1470,11 @@ public final class ChunkHolderManager {
+     }
+ 
+     public boolean processTicketUpdates() {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         co.aikar.timings.MinecraftTimings.distanceManagerTick.startTiming(); try { // Paper - add timings for distance manager
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TICKET_LEVEL_UPDATE_PROCESSING); try { // Folia - profiler
+         return this.processTicketUpdates(true, true, null);
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TICKET_LEVEL_UPDATE_PROCESSING); } // Folia - profiler
+         } finally { co.aikar.timings.MinecraftTimings.distanceManagerTick.stopTiming(); } // Paper - add timings for distance manager
+     }
+ 
+diff --git a/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java b/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
+index 08075b8895f816420c2a940bf551dfada3c0cd9e..2c688d886b14679d7ab4a485da2675e97c2bac43 100644
+--- a/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
++++ b/src/main/java/io/papermc/paper/chunk/system/scheduling/NewChunkHolder.java
+@@ -1750,6 +1750,8 @@ public final class NewChunkHolder {
+ 
+     public SaveStat save(final boolean shutdown, final boolean unloading) {
+         TickThread.ensureTickThread(this.world, this.chunkX, this.chunkZ, "Cannot save data off-main");
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_SAVE); try { // Folia - profiler
+ 
+         ChunkAccess chunk = this.getCurrentChunk();
+         PoiChunk poi = this.getPoiChunk();
+@@ -1796,6 +1798,7 @@ public final class NewChunkHolder {
+         }
+ 
+         return executedUnloadTask | canSaveChunk | canSaveEntities | canSavePOI ? new SaveStat(executedUnloadTask || canSaveChunk, canSaveEntities, canSavePOI): null;
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_SAVE); } // Folia - profiler
+     }
+ 
+     static final class AsyncChunkSerializeTask implements Runnable {
+diff --git a/src/main/java/io/papermc/paper/command/PaperCommands.java b/src/main/java/io/papermc/paper/command/PaperCommands.java
+index a587d83b78af4efc484f939529acf70834f60d7e..45f76aaaa7dedb77a83b4a2c87905bf9a099a93c 100644
+--- a/src/main/java/io/papermc/paper/command/PaperCommands.java
++++ b/src/main/java/io/papermc/paper/command/PaperCommands.java
+@@ -20,6 +20,7 @@ public final class PaperCommands {
+         COMMANDS.put("callback", new CallbackCommand("callback"));
+         COMMANDS.put("mspt", new MSPTCommand("mspt"));
+         COMMANDS.put("tps", new io.papermc.paper.threadedregions.commands.CommandServerHealth()); // Folia - region threading
++        COMMANDS.put("profiler", new io.papermc.paper.threadedregions.commands.CommandProfiler()); // Folia - region threading - profiler
+     }
+ 
+     public static void registerCommands(final MinecraftServer server) {
+diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
+index 150610d7bf25416dbbde7f003c47da562acc68ba..865044d40a95d201765435cbc14b0384980eebf6 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
++++ b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
+@@ -66,8 +66,13 @@ public final class TickRegionScheduler {
+         tickThreadRunner.currentTickingRegion = region;
+         if (region != null) {
+             tickThreadRunner.currentTickingWorldRegionizedData = region.regioniser.world.worldRegionData.get();
++            // Folia start - profiler
++            final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = region.getData().profiler;
++            tickThreadRunner.profiler = profiler == null ? ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle.NO_OP_HANDLE : profiler;
++            // Folia end - profiler
+         } else {
+             tickThreadRunner.currentTickingWorldRegionizedData = null;
++            tickThreadRunner.profiler = ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle.NO_OP_HANDLE; // Folia - profiler
+         }
+     }
+ 
+@@ -122,6 +127,17 @@ public final class TickRegionScheduler {
+         return tickThreadRunner.currentTickingTask;
+     }
+ 
++    // Folia start - profiler
++    public static ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle getProfiler() {
++        final Thread currThread = Thread.currentThread();
++        if (!(currThread instanceof TickThreadRunner tickThreadRunner)) {
++            return ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle.NO_OP_HANDLE;
++        }
++        return tickThreadRunner.profiler;
++    }
++    // Folia end - profiler
++
++
+     /**
+      * Schedules the given region
+      * @throws IllegalStateException If the region is already scheduled or is ticking
+@@ -199,6 +215,9 @@ public final class TickRegionScheduler {
+         private ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> currentTickingRegion;
+         private RegionizedWorldData currentTickingWorldRegionizedData;
+         private SchedulerThreadPool.SchedulableTick currentTickingTask;
++        // Folia start - profiler
++        private ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle.NO_OP_HANDLE;
++        // Folia end - profiler
+ 
+         public TickThreadRunner(final Runnable run, final String name) {
+             super(run, name);
+diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
+index 902e82854c89779c7e23c63d1be5b04dad2a61e3..fef65cc17be9fc465b2668b8cfbde104342c9d97 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
++++ b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
+@@ -76,6 +76,11 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+     @Override
+     public void onRegionDestroy(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> region) {
+         // nothing for now
++        // Folia start - profiler
++        if (region.getData().profiler != null) {
++            region.getData().profiler.stopProfiler();
++        }
++        // Folia end - profiler
+     }
+ 
+     @Override
+@@ -98,13 +103,23 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+     @Override
+     public void preMerge(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> from,
+                          final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> into) {
+-
++        // Folia start - profiler
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = from.getData().profiler;
++        if (profiler != null) {
++            profiler.profilerGroup.preMerge(from, into);
++        }
++        // Folia end - profiler
+     }
+ 
+     @Override
+     public void preSplit(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> from,
+                          final java.util.List<ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData>> into) {
+-
++        // Folia start - profiler
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = from.getData().profiler;
++        if (profiler != null) {
++            profiler.profilerGroup.preSplit(from, into);
++        }
++        // Folia end - profiler
+     }
+ 
+     public static final class TickRegionSectionData implements ThreadedRegionizer.ThreadedRegionSectionData {}
+@@ -162,6 +177,8 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+         // async-safe read-only region data
+         private final RegionStats regionStats;
+ 
++        public volatile ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler; // Folia - profiler
++
+         private TickRegionData(final ThreadedRegionizer.ThreadedRegion<TickRegionData, TickRegionSectionData> region) {
+             this.region = region;
+             this.world = region.regioniser.world;
+@@ -367,13 +384,29 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+             return this.region.region.markNotTicking();
+         }
+ 
++        // Folia start - profiler
++        @Override
++        protected void addTickTime(final TickRegionScheduler.TickTime time) {
++            super.addTickTime(time);
++
++            final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
++            profiler.addTickTime(time);
++            profiler.checkStop();
++         }
++         // Folia end - profiler
++
+         @Override
+         protected void tickRegion(final int tickCount, final long startTime, final long scheduledEnd) {
++            final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
++            profiler.startTick(); try { // Folia - profiler
+             MinecraftServer.getServer().tickServer(startTime, scheduledEnd, TimeUnit.MILLISECONDS.toMillis(10L), this.region);
++            } finally { profiler.stopTick(); } // Folia - profiler
+         }
+ 
+         @Override
+         protected boolean runRegionTasks(final BooleanSupplier canContinue) {
++            final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia start - profiler
++            profiler.startInBetweenTick(); try { // Folia - profiler
+             final RegionizedTaskQueue.RegionTaskQueueData queue = this.region.taskQueueData;
+ 
+             boolean processedChunkTask = false;
+@@ -394,6 +427,7 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+                 this.region.world.chunkTaskScheduler.chunkHolderManager.processTicketUpdates();
+             }
+             return true;
++            } finally { profiler.stopInBetweenTick(); } // Folia - profiler
+         }
+ 
+         @Override
+diff --git a/src/main/java/io/papermc/paper/threadedregions/commands/CommandProfiler.java b/src/main/java/io/papermc/paper/threadedregions/commands/CommandProfiler.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e36fd244f71a92d11c6ee45944948be5c1be2932
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/threadedregions/commands/CommandProfiler.java
+@@ -0,0 +1,245 @@
++package io.papermc.paper.threadedregions.commands;
++
++import ca.spottedleaf.leafprofiler.RegionizedProfiler;
++import com.mojang.logging.LogUtils;
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickData;
++import io.papermc.paper.threadedregions.TickRegions;
++import io.papermc.paper.util.MCUtil;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.NamedTextColor;
++import net.kyori.adventure.text.format.TextColor;
++import net.minecraft.util.Mth;
++import net.minecraft.world.level.ChunkPos;
++import org.bukkit.Bukkit;
++import org.bukkit.World;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.craftbukkit.CraftWorld;
++import org.bukkit.entity.Entity;
++import org.slf4j.Logger;
++import java.io.File;
++import java.io.IOException;
++import java.nio.charset.StandardCharsets;
++import java.nio.file.Files;
++import java.nio.file.StandardOpenOption;
++import java.text.DecimalFormat;
++import java.util.ArrayList;
++import java.util.List;
++import java.util.Objects;
++import java.util.Set;
++import java.util.concurrent.ThreadLocalRandom;
++
++public final class CommandProfiler extends Command {
++
++    private static final Logger LOGGER = LogUtils.getLogger();
++
++    private static final ThreadLocal<DecimalFormat> THREE_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0.000");
++    });
++    private static final ThreadLocal<DecimalFormat> TWO_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0.00");
++    });
++    private static final ThreadLocal<DecimalFormat> ONE_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0.0");
++    });
++    private static final ThreadLocal<DecimalFormat> NO_DECIMAL_PLACES = ThreadLocal.withInitial(() -> {
++        return new DecimalFormat("#,##0");
++    });
++    private static final TextColor ORANGE = TextColor.color(255, 165, 0);
++
++    public CommandProfiler() {
++        super("profiler");
++        this.setUsage("/<command> <world> <block x> <block z> <time in s> [radius, default 100 blocks]");
++        this.setDescription("Reports information about server health.");
++        this.setPermission("bukkit.command.tps");
++    }
++
++    @Override
++    public boolean execute(final CommandSender sender, final String commandLabel, final String[] args) {
++        if (args.length < 4 || args.length > 5) {
++            sender.sendMessage(Component.text("Usage: /profiler <world> <block x> <block z> <time in s> [radius, default 100 blocks]", NamedTextColor.RED));
++            return true;
++        }
++
++        final World world = Bukkit.getWorld(args[0]);
++        if (world == null) {
++            sender.sendMessage(Component.text("No such world '" + args[0] + "'", NamedTextColor.RED));
++            return true;
++        }
++
++        final double blockX;
++        final double blockZ;
++        final double time; // seconds
++        try {
++            blockX = (args[1].equals("~") && sender instanceof Entity entity) ? entity.getLocation().getX() : Double.parseDouble(args[1]);
++        } catch (final NumberFormatException ex) {
++            sender.sendMessage(Component.text("Invalid input for block x: " + args[1], NamedTextColor.RED));
++            return true;
++        }
++        try {
++            blockZ = (args[2].equals("~") && sender instanceof Entity entity) ? entity.getLocation().getZ() : Double.parseDouble(args[2]);
++        } catch (final NumberFormatException ex) {
++            sender.sendMessage(Component.text("Invalid input for block z: " + args[2], NamedTextColor.RED));
++            return true;
++        }
++        try {
++            time = Double.parseDouble(args[3]);
++        } catch (final NumberFormatException ex) {
++            sender.sendMessage(Component.text("Invalid input for time: " + args[3], NamedTextColor.RED));
++            return true;
++        }
++
++        final double radius;
++        if (args.length > 4) {
++            try {
++                radius = Double.parseDouble(args[4]);
++            } catch (final NumberFormatException ex) {
++                sender.sendMessage(Component.text("Invalid input for radius: " + args[4], NamedTextColor.RED));
++                return true;
++            }
++        } else {
++            radius = 100.0;
++        }
++
++        final int fromChunkX = Mth.floor(blockX - radius) >> 4;
++        final int fromChunkZ = Mth.floor(blockZ - radius) >> 4;
++        final int toChunkX = Mth.floor(blockX + radius) >> 4;
++        final int toChunkZ = Mth.floor(blockZ + radius) >> 4;
++
++        final RegionizedProfiler profiler = new RegionizedProfiler(
++            ThreadLocalRandom.current().nextLong(), (long)Math.ceil(time * 1.0E9),
++            (final RegionizedProfiler.ProfileResults results) -> {
++                MCUtil.asyncExecutor.execute(() -> {
++                    writeResults(results);
++                    sender.sendMessage(
++                        Component.text()
++                            .append(Component.text("Finished profiler #", NamedTextColor.DARK_GRAY))
++                            .append(Component.text(Long.toString(results.profileId()), ORANGE))
++                            .append(Component.text(", result available in ", NamedTextColor.DARK_GRAY))
++                            .append(Component.text("./profiler/" + results.profileId(), ORANGE))
++                            .build()
++                    );
++                });
++            }
++        );
++
++        final int regionCount = ((CraftWorld)world).getHandle().regioniser.computeForRegions(
++            fromChunkX, fromChunkZ, toChunkX, toChunkZ,
++            (final Set<ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData>> set) -> {
++                for (final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region : set) {
++                    final TickRegions.TickRegionData data = region.getData();
++                    final ChunkPos center = region.getCenterChunk();
++
++                    if (data.profiler != null) {
++                        MCUtil.asyncExecutor.execute(() -> {
++                            sender.sendMessage(
++                                Component.text()
++                                    .append(Component.text("Region #", NamedTextColor.DARK_GRAY))
++                                    .append(Component.text(region.id, ORANGE))
++                                    .append(Component.text(" centered on ", NamedTextColor.DARK_GRAY))
++                                    .append(Component.text(Objects.toString(center), ORANGE))
++                                    .append(Component.text(" already is being profiled", NamedTextColor.DARK_GRAY))
++                                    .build()
++                            );
++                        });
++                        continue;
++                    }
++
++                    profiler.createProfiler(region);
++                    MCUtil.asyncExecutor.execute(() -> {
++                        sender.sendMessage(
++                            Component.text()
++                                .append(Component.text("Started profiler #", NamedTextColor.DARK_GRAY))
++                                .append(Component.text(Long.toString(profiler.id), ORANGE))
++                                .append(Component.text(" for region #", NamedTextColor.DARK_GRAY))
++                                .append(Component.text(Long.toString(region.id), ORANGE))
++                                .append(Component.text(" centered on chunk ", NamedTextColor.DARK_GRAY))
++                                .append(Component.text(Objects.toString(center), ORANGE))
++                                .build()
++                        );
++                    });
++                }
++            }
++        );
++
++        if (regionCount == 0) {
++            sender.sendMessage(
++                Component.text()
++                    .append(Component.text("No regions around specified location in radius to profile", NamedTextColor.RED))
++            );
++        }
++
++        return true;
++    }
++
++    private static void writeLines(final File file, final List<String> lines) {
++        try {
++            Files.write(
++                file.toPath(), lines, StandardCharsets.UTF_8,
++                StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE
++            );
++        } catch (final IOException ex) {
++            LOGGER.warn("Failed to write to profiler file " + file.getAbsolutePath(), ex);
++        }
++    }
++
++    private static void writeResults(final RegionizedProfiler.ProfileResults results) {
++        final File directory = new File(new File(".", "profiler"), Long.toString(results.profileId()));
++
++        directory.mkdirs();
++
++        // write region data
++        for (final RegionizedProfiler.RegionTimings regionTimings : results.timings()) {
++            final File regionProfile = new File(directory, "region-" + regionTimings.regionId() + ".txt");
++            final TickData.TickReportData tickReport = regionTimings.tickData().generateTickReport(null, regionTimings.endTime());
++
++            final List<String> out = new ArrayList<>();
++            out.add("Total time: " + THREE_DECIMAL_PLACES.get().format(1.0E-9 * (regionTimings.endTime() - regionTimings.startTime())) + "s");
++            out.add("Total Ticks: " + NO_DECIMAL_PLACES.get().format(tickReport == null ? 0 : tickReport.collectedTicks()));
++            out.add("Utilisation: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 0.0 : 100.0 * tickReport.utilisation()) + "%");
++            out.add("");
++            out.add("Min TPS: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 20.0 : tickReport.tpsData().segmentAll().least()));
++            out.add("Median TPS: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 20.0 : tickReport.tpsData().segmentAll().median()));
++            out.add("Average TPS: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 20.0 : tickReport.tpsData().segmentAll().average()));
++            out.add("Max TPS: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 20.0 : tickReport.tpsData().segmentAll().greatest()));
++            out.add("");
++            out.add("Min MSPT: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 0.0 : 1.0E-6 * tickReport.timePerTickData().segmentAll().least()));
++            out.add("Median MSPT: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 0.0 : 1.0E-6 *tickReport.timePerTickData().segmentAll().median()));
++            out.add("Average MSPT: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 0.0 : 1.0E-6 *tickReport.timePerTickData().segmentAll().average()));
++            out.add("Max MSPT: " + THREE_DECIMAL_PLACES.get().format(tickReport == null ? 0.0 : 1.0E-6 *tickReport.timePerTickData().segmentAll().greatest()));
++            out.add("");
++
++            out.addAll(regionTimings.profiler().dumpToString());
++            writeLines(regionProfile, out);
++        }
++
++        // write journal
++        final File journal = new File(directory, "journal.txt");
++        final List<String> journalLines = new ArrayList<>();
++
++        for (final RegionizedProfiler.RecordedOperation operation : results.operations()) {
++            final String indent = "    ";
++            journalLines.add("Recorded Operation:");
++            journalLines.add(indent + "Type: " + operation.type());
++            journalLines.add(indent + "Time: " + THREE_DECIMAL_PLACES.get().format(1.0E-9 * (operation.time() - results.startTime())) + "s");
++            journalLines.add(indent + "From Region: " + operation.regionOfInterest());
++            journalLines.add(indent + "Target Other Regions: " + operation.targetRegions().toString());
++        }
++
++        journalLines.add("Total time: " + THREE_DECIMAL_PLACES.get().format(1.0E-9 * (results.endTime() - results.startTime())) + "s");
++        writeLines(journal, journalLines);
++
++    }
++
++    @Override
++    public List<String> tabComplete(final CommandSender sender, final String alias, final String[] args) throws IllegalArgumentException {
++        if (args.length == 0) {
++            return CommandUtil.getSortedList(Bukkit.getWorlds(), World::getName);
++        }
++        if (args.length == 1) {
++            return CommandUtil.getSortedList(Bukkit.getWorlds(), World::getName, args[0]);
++        }
++        return new ArrayList<>();
++    }
++}
+diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+index c06bed93f6a701b1639c1cc334802e7b802431a5..e635f21e3c9c000da9c9da9bf2ec9ed87f664da5 100644
+--- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java
++++ b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+@@ -50,7 +50,10 @@ public class PacketUtils {
+                 if (listener.shouldHandleMessage(packet)) {
+                     co.aikar.timings.Timing timing = co.aikar.timings.MinecraftTimings.getPacketTiming(packet); // Paper - timings
+                     try (co.aikar.timings.Timing ignored = timing.startTiming()) { // Paper - timings
++                        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
++                        final int packetTimerId = profiler.getOrCreateTimerAndStart(() -> "Packet Handler: ".concat(io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(packet.getClass().getName()))); try { // Folia - profiler
+                         packet.handle(listener);
++                        } finally { profiler.stopTimer(packetTimerId); } // Folia - profiler
+                     } catch (Exception exception) {
+                         if (exception instanceof ReportedException) {
+                             ReportedException reportedexception = (ReportedException) exception;
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index f9cf331202d0768a054e575c8909369920b3d59f..2f2a8a0c05024115f3b7bd69ae400fadff2f36c5 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1462,6 +1462,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     // Folia start - region threading
+     public void tickServer(long startTime, long scheduledEnd, long targetBuffer,
+                            io.papermc.paper.threadedregions.TickRegions.TickRegionData region) {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         if (region != null) {
+             region.world.getCurrentWorldData().updateTickData();
+             if (region.world.checkInitialised.get() != ServerLevel.WORLD_INIT_CHECKED) {
+@@ -1496,10 +1497,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+         // Folia start - region threading
+         if (region != null) {
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.INTERNAL_TICK_TASKS); try { // Folia - profiler
+             region.getTaskQueueData().drainTasks();
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.INTERNAL_TICK_TASKS); } // Folia - profiler
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLUGIN_TICK_TASKS); try { // Folia - profiler
+             ((io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler)Bukkit.getRegionScheduler()).tick();
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLUGIN_TICK_TASKS); } // Folia - profiler
+             // now run all the entity schedulers
+             // TODO there has got to be a more efficient variant of this crap
++            long tickedEntitySchedulers = 0L; // Folia - profiler
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_SCHEDULER_TICK); try { // Folia - profiler
+             for (Entity entity : region.world.getCurrentWorldData().getLocalEntitiesCopy()) {
+                 if (!io.papermc.paper.util.TickThread.isTickThreadFor(entity) || entity.isRemoved()) {
+                     continue;
+@@ -1507,10 +1514,15 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 org.bukkit.craftbukkit.entity.CraftEntity bukkit = entity.getBukkitEntityRaw();
+                 if (bukkit != null) {
+                     bukkit.taskScheduler.executeTick();
++                    ++tickedEntitySchedulers; // Folia - profiler
+                 }
+             }
++            profiler.addCounter(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_SCHEDULERS_TICKED, tickedEntitySchedulers); // Folia - profiler
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_SCHEDULER_TICK); } // Folia - profiler
+             // now tick connections
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CONNECTION_TICK); try { // Folia - profiler
+             region.world.getCurrentWorldData().tickConnections(); // Folia - region threading
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CONNECTION_TICK); } // Folia - profiler
+         }
+         // Folia end - region threading
+ 
+@@ -1528,6 +1540,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         }
+         this.profiler.push("save");
+         final boolean fullSave = autosavePeriod > 0 && io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick() % autosavePeriod == 0; // Folia - region threading
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.AUTOSAVE); try { // Folia - profiler
+         try {
+             this.isSaving = true;
+             if (playerSaveInterval > 0) {
+@@ -1541,6 +1554,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         } finally {
+             this.isSaving = false;
+         }
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.AUTOSAVE); } // Folia - profiler
+         this.profiler.pop();
+         // Paper end
+         io.papermc.paper.util.CachedLists.reset(); // Paper
+@@ -1598,6 +1612,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     }
+ 
+     public void tickChildren(BooleanSupplier shouldKeepTicking, io.papermc.paper.threadedregions.TickRegions.TickRegionData region) { // Folia - region threading
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         final io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = io.papermc.paper.threadedregions.TickRegionScheduler.getCurrentRegionizedWorldData(); // Folia - regionised ticking
+         if (region == null) this.getPlayerList().getPlayers().forEach((entityplayer) -> { // Folia - region threading
+             entityplayer.connection.suspendFlushing();
+@@ -1664,12 +1679,14 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+             try {
+                 worldserver.timings.doTick.startTiming(); // Spigot
++                profiler.startTimer(worldserver.tickTimerId); try { // Folia - profiler
+                 worldserver.tick(shouldKeepTicking, region); // Folia - region threading
+                 // Paper start
+                 for (final io.papermc.paper.chunk.SingleThreadChunkRegionManager regionManager : worldserver.getChunkSource().chunkMap.regionManagers) {
+                     regionManager.recalculateRegions();
+                 }
+                 // Paper end
++                } finally { profiler.stopTimer(worldserver.tickTimerId); } // Folia - profiler
+                 worldserver.timings.doTick.stopTiming(); // Spigot
+             } catch (Throwable throwable) {
+                 // Spigot Start
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index a1cbf387c72482034eeee6be8a5c2228131601a9..0f7e53dbac964391763bf6b380e65ce955a8a7a5 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -466,16 +466,21 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+     }
+ 
+     protected void tick(BooleanSupplier shouldKeepTicking) {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         ProfilerFiller gameprofilerfiller = this.level.getProfiler();
+ 
+         try (Timing ignored = this.level.timings.poiUnload.startTiming()) { // Paper
+         gameprofilerfiller.push("poi");
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.POI_MANAGER_TICK); try { // Folia - profiler
+         this.poiManager.tick(shouldKeepTicking);
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.POI_MANAGER_TICK); } // Folia - profiler
+         } // Paper
+         gameprofilerfiller.popPush("chunk_unload");
+         if (!this.level.noSave()) {
+             try (Timing ignored = this.level.timings.chunkUnload.startTiming()) { // Paper
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PROCESS_UNLOADS); try { // Folia - profiler
+             this.processUnloads(shouldKeepTicking);
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PROCESS_UNLOADS); } // Folia - profiler
+             } // Paper
+         }
+ 
+@@ -1088,9 +1093,14 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+ 
+     // Folia start - region threading - replace entity tracking ticking
+     private void foliaEntityTrackerTick() {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         io.papermc.paper.threadedregions.RegionizedWorldData worldData = this.level.getCurrentWorldData();
+         io.papermc.paper.util.player.NearbyPlayers nearbyPlayers = worldData.getNearbyPlayers();
++        long totalEntities = 0L; // Folia - profiler
++        long totalUnloadedEntities = 0L; // Folia - profiler
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TRACKER_TICK); try { // Folia - profiler
+         for (Entity entity : worldData.getLoadedEntities()) {
++            ++totalEntities; // Folia - profiler
+             TrackedEntity tracker = entity.tracker;
+             if (tracker == null) {
+                 continue;
+@@ -1100,12 +1110,16 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         }
+         // process unloads
+         for (Entity entity : worldData.takeTrackingUnloads()) {
++            ++totalUnloadedEntities; // Folia - profiler
+             TrackedEntity tracker = entity.tracker;
+             if (tracker == null) {
+                 continue;
+             }
+             tracker.clearPlayers();
+         }
++        profiler.addCounter(ca.spottedleaf.leafprofiler.LProfilerRegistry.TRACKED_ENTITY_COUNTS, totalEntities); // Folia - profiler
++        profiler.addCounter(ca.spottedleaf.leafprofiler.LProfilerRegistry.TRACKED_UNLOADED_ENTITY_COUNTS, totalUnloadedEntities); // Folia - profiler
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TRACKER_TICK); } // Folia - profiler
+     }
+     // Folia end - region threading - replace entity tracking ticking
+ 
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index 18735dbd0d2bae1576d2bdb7402d98e9affbd599..72a5973c6e150533ec70496d72b53c80a142eef7 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -436,16 +436,23 @@ public class ServerChunkCache extends ChunkSource {
+ 
+     @Override
+     public void tick(BooleanSupplier shouldKeepTicking, boolean tickChunks) {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         this.level.getProfiler().push("purge");
+         this.level.timings.doChunkMap.startTiming(); // Spigot
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_HOLDER_MANAGER_TICK); try { // Folia - profiler
+         this.distanceManager.purgeStaleTickets();
+         this.runDistanceManagerUpdates();
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_HOLDER_MANAGER_TICK); } // Folia - profiler
+         this.level.timings.doChunkMap.stopTiming(); // Spigot
+         this.level.getProfiler().popPush("chunks");
+         if (tickChunks) {
+             this.level.timings.chunks.startTiming(); // Paper - timings
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLAYER_CHUNK_LOADER_TICK); try { // Folia - profiler
+             this.chunkMap.level.playerChunkLoader.tick(); // Paper - replace player chunk loader - this is mostly required to account for view distance changes
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLAYER_CHUNK_LOADER_TICK); } // Folia - profiler
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_TICK); try { // Folia - profiler
+             this.tickChunks();
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_TICK); } // Folia - profiler
+             this.level.timings.chunks.stopTiming(); // Paper - timings
+         }
+ 
+@@ -459,6 +466,7 @@ public class ServerChunkCache extends ChunkSource {
+ 
+     private void tickChunks() {
+         io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = this.level.getCurrentWorldData(); // Folia - region threading
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         long i = this.level.getGameTime();
+         long j = 1; // Folia - region threading
+ 
+@@ -480,6 +488,7 @@ public class ServerChunkCache extends ChunkSource {
+             int l = this.distanceManager.getNaturalSpawnChunkCount();
+             // Paper start - per player mob spawning
+             NaturalSpawner.SpawnState spawnercreature_d; // moved down
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MOB_SPAWN_ENTITY_COUNT); try { // Folia - profiler
+             if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
+                 // re-set mob counts
+                 for (ServerPlayer player : this.level.players) {
+@@ -499,6 +508,7 @@ public class ServerChunkCache extends ChunkSource {
+             } else {
+                 spawnercreature_d = NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false); // Folia - region threading
+             }
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MOB_SPAWN_ENTITY_COUNT); } // Folia - profiler
+             // Paper end
+             this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings
+ 
+@@ -566,6 +576,9 @@ public class ServerChunkCache extends ChunkSource {
+             }
+             try {
+             // Paper end - optimise chunk tick iteration
++            long spawnChunkCount = 0L; // Folia - profiler
++            long randomChunkCount = 0L; // Folia - profiler
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.SPAWN_AND_RANDOM_TICK); try { // Folia - profiler
+             while (iterator1.hasNext()) {
+                 LevelChunk chunk1 = iterator1.next(); // Paper - optimise chunk tick iteration
+                 ChunkPos chunkcoordintpair = chunk1.getPos();
+@@ -596,15 +609,20 @@ public class ServerChunkCache extends ChunkSource {
+                 if (tick && chunk1.chunkStatus.isOrAfter(net.minecraft.server.level.FullChunkStatus.ENTITY_TICKING)) { // Paper - optimise chunk tick iteration
+                     chunk1.incrementInhabitedTime(j);
+                     if (spawn && flag2 && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair)) { // Spigot // Paper - optimise chunk tick iteration
++                        ++spawnChunkCount; // Folia - profiler
+                         NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1);
+                     }
+ 
+                     if (true || this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) { // Paper - optimise chunk tick iteration
++                        ++randomChunkCount; // Folia - profiler
+                         this.level.tickChunk(chunk1, k);
+                         if ((chunksTicked++ & 1) == 0) net.minecraft.server.MinecraftServer.getServer().executeMidTickTasks(); // Paper
+                     }
+                 }
+             }
++            profiler.addCounter(ca.spottedleaf.leafprofiler.LProfilerRegistry.SPAWN_CHUNK_COUNT, spawnChunkCount); // Folia - profiler
++            profiler.addCounter(ca.spottedleaf.leafprofiler.LProfilerRegistry.RANDOM_CHUNK_TICK_COUNT, randomChunkCount); // Folia - profiler
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.SPAWN_AND_RANDOM_TICK); } // Folia - profiler
+             // Paper start - optimise chunk tick iteration
+             } finally {
+                 if (iterator1 instanceof io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.Iterator safeIterator) {
+@@ -615,9 +633,11 @@ public class ServerChunkCache extends ChunkSource {
+             this.level.timings.chunkTicks.stopTiming(); // Paper
+             gameprofilerfiller.popPush("customSpawners");
+             if (flag2) {
++                profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MISC_MOB_SPAWN_TICK); try { // Folia - profiler
+                 try (co.aikar.timings.Timing ignored = this.level.timings.miscMobSpawning.startTiming()) { // Paper - timings
+                 this.level.tickCustomSpawners(this.spawnEnemies, this.spawnFriendlies);
+                 } // Paper - timings
++                } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MISC_MOB_SPAWN_TICK); } // Folia - profiler
+             }
+ 
+             gameprofilerfiller.popPush("broadcast");
+@@ -626,6 +646,7 @@ public class ServerChunkCache extends ChunkSource {
+             // Paper start - optimise chunk tick iteration
+             // Folia start - region threading
+             if (!this.level.needsChangeBroadcasting.isEmpty()) {
++                profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BROADCAST_BLOCK_CHANGES); try { // Folia - profiler
+                 for (Iterator<ChunkHolder> iterator = this.level.needsChangeBroadcasting.iterator(); iterator.hasNext();) {
+                     ChunkHolder holder = iterator.next();
+                     if (!io.papermc.paper.util.TickThread.isTickThreadFor(holder.newChunkHolder.world, holder.pos)) {
+@@ -637,6 +658,7 @@ public class ServerChunkCache extends ChunkSource {
+                         iterator.remove();
+                     }
+                 }
++                } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BROADCAST_BLOCK_CHANGES); } // Folia - profiler
+             }
+             // Folia end - region threading
+             // Paper end - optimise chunk tick iteration
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 8b41da9d1f43340b6ba3812a93f681419d0d7cd8..a4af151e6a2d428d7c9b2a81ada7310b73867d5a 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -891,6 +891,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+ 
+     public void tick(BooleanSupplier shouldKeepTicking, io.papermc.paper.threadedregions.TickRegions.TickRegionData region) { // Folia - regionised ticking
+         final io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = this.getCurrentWorldData(); // Folia - regionised ticking
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+         regionizedWorldData.setHandlingTick(true); // Folia - regionised ticking
+@@ -910,24 +911,34 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         if (!this.isDebug()) {
+             j = regionizedWorldData.getRedstoneGameTime(); // Folia - region threading
+             gameprofilerfiller.push("blockTicks");
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BLOCK_TICK); try { // Folia - profiler
+             regionizedWorldData.getBlockLevelTicks().tick(j, 65536, this::tickBlock); // Folia - region ticking
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BLOCK_TICK); } // Folia - profiler
+             gameprofilerfiller.popPush("fluidTicks");
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.FLUID_TICK); try { // Folia - profiler
+             regionizedWorldData.getFluidLevelTicks().tick(j, 65536, this::tickFluid); // Folia - region ticking
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.FLUID_TICK); } // Folia - profiler
+             gameprofilerfiller.pop();
+         }
+         timings.scheduledBlocks.stopTiming(); // Paper
+ 
+         gameprofilerfiller.popPush("raid");
+         this.timings.raids.startTiming(); // Paper - timings
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.RAIDS_TICK); try { // Folia - profiler
+         this.raids.tick();
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.RAIDS_TICK); } // Folia - profiler
+         this.timings.raids.stopTiming(); // Paper - timings
+         gameprofilerfiller.popPush("chunkSource");
+         this.timings.chunkProviderTick.startTiming(); // Paper - timings
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_PROVIDER_TICK); try { // Folia - profiler
+         this.getChunkSource().tick(shouldKeepTicking, true);
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.CHUNK_PROVIDER_TICK); } // Folia - profiler
+         this.timings.chunkProviderTick.stopTiming(); // Paper - timings
+         gameprofilerfiller.popPush("blockEvents");
+         timings.doSounds.startTiming(); // Spigot
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BLOCK_EVENT_TICK); try { // Folia - profiler
+         this.runBlockEvents();
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.BLOCK_EVENT_TICK); } // Folia - profiler
+         timings.doSounds.stopTiming(); // Spigot
+         regionizedWorldData.setHandlingTick(false); // Folia - regionised ticking
+         gameprofilerfiller.pop();
+@@ -941,6 +952,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             gameprofilerfiller.push("entities");
+             timings.tickEntities.startTiming(); // Spigot
+             if (this.dragonFight != null) {
++                profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.DRAGON_FIGHT_TICK); try { // Folia - profiler
+                 if (io.papermc.paper.util.TickThread.isTickThreadFor(this, this.dragonFight.origin)) { // Folia - region threading
+                 gameprofilerfiller.push("dragonFight");
+                 this.dragonFight.tick();
+@@ -953,10 +965,12 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                         fightCenter
+                     );
+                 } // Folia end - region threading
++                } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.DRAGON_FIGHT_TICK); } // Folia - profiler
+             }
+ 
+             org.spigotmc.ActivationRange.activateEntities(this); // Spigot
+             timings.entityTick.startTiming(); // Spigot
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); try { // Folia - profiler
+             regionizedWorldData.forEachTickingEntity((entity) -> { // Folia - regionised ticking
+                 if (!entity.isRemoved()) {
+                     if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed
+@@ -984,10 +998,13 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                     }
+                 }
+             });
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); } // Folia - profiler
+             timings.entityTick.stopTiming(); // Spigot
+             timings.tickEntities.stopTiming(); // Spigot
+             gameprofilerfiller.pop();
++            profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY); try { // Folia - profiler
+             this.tickBlockEntities();
++            } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY); } // Folia - profiler
+         }
+ 
+         gameprofilerfiller.push("entityManagement");
+@@ -1047,12 +1064,15 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     }
+ 
+     public void tickCustomSpawners(boolean spawnMonsters, boolean spawnAnimals) {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         Iterator iterator = this.customSpawners.iterator();
+ 
+         while (iterator.hasNext()) {
+             CustomSpawner mobspawner = (CustomSpawner) iterator.next();
+ 
++            final int customSpawnerTimer = profiler.getOrCreateTimerAndStart(() -> "Misc Spawner: ".concat(io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(mobspawner.getClass().getName()))); try { // Folia - profiler
+             mobspawner.tick(this, spawnMonsters, spawnAnimals);
++            } finally { profiler.stopTimer(customSpawnerTimer); } // Folia - profiler
+         }
+ 
+     }
+@@ -1494,6 +1514,11 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         // Paper start- timings
+         final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity);
+         timer = isActive ? entity.getType().tickTimer.startTiming() : entity.getType().inactiveTickTimer.startTiming(); // Paper
++        // Folia start - timer
++        final int timerId = isActive ? entity.getType().tickTimerId : entity.getType().inactiveTickTimerId;
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
++        profiler.startTimer(timerId);
++        // Folia end - timer
+         try {
+         // Paper end - timings
+         entity.setOldPosAndRot();
+@@ -1519,7 +1544,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         // Folia end - region threading
+         } else { entity.inactiveTick(); } // Paper - EAR 2
+         this.getProfiler().pop();
+-        } finally { timer.stopTiming(); } // Paper - timings
++        } finally { timer.stopTiming(); profiler.stopTimer(timerId); } // Paper - timings // Folia - timer
+         Iterator iterator = entity.getPassengers().iterator();
+ 
+         while (iterator.hasNext()) {
+@@ -1543,6 +1568,11 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                 // Paper - EAR 2
+                 final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(passenger);
+                 co.aikar.timings.Timing timer = isActive ? passenger.getType().passengerTickTimer.startTiming() : passenger.getType().passengerInactiveTickTimer.startTiming(); // Paper
++                // Folia start - timer
++                final int timerId = isActive ? passenger.getType().tickTimerId : passenger.getType().inactiveTickTimerId;
++                final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
++                profiler.startTimer(timerId);
++                // Folia end - timer
+                 try {
+                 // Paper end
+                 passenger.setOldPosAndRot();
+@@ -1582,7 +1612,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                     this.tickPassenger(passenger, entity2);
+                 }
+ 
+-            } finally { timer.stopTiming(); }// Paper - EAR2 timings
++            } finally { timer.stopTiming(); profiler.stopTimer(timerId); }// Paper - EAR2 timings // Folia - timer
+             }
+         } else {
+             passenger.stopRiding();
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 7bfbcda5cf086c3c50f8cb202ceaf685a899141c..9da89e8e9569666227081ebc6cb1f0348e1a183d 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1301,6 +1301,7 @@ public abstract class PlayerList {
+ 
+     public void saveAll(int interval) {
+         io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         MinecraftTimings.savePlayers.startTiming(); // Paper
+         int numSaved = 0;
+         long now = System.nanoTime(); // Folia - region threading
+@@ -1312,7 +1313,9 @@ public abstract class PlayerList {
+             }
+             // Folia end - region threading
+             if (interval == -1 || now - entityplayer.lastSave >= timeInterval) { // Folia - region threading
++                profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLAYER_SAVE); try { // Folia - profiler
+                 this.save(entityplayer);
++                } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.PLAYER_SAVE); } // Folia - profiler
+                 // Folia start - region threading
+                 if (interval != -1 && max != -1 && ++numSaved >= max) {
+                     break;
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index 73871f456a85bda1e51f54986d0e61fb629822e8..3f3494c20cd15a721090f1b36293562a6b834b14 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -322,6 +322,13 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+         return BuiltInRegistries.ENTITY_TYPE.getOptional(ResourceLocation.tryParse(id));
+     }
+ 
++    // Folia start - profiler
++    public final int tickTimerId;
++    public final int inactiveTickTimerId;
++    public final int passengerTickTimerId;
++    public final int passengerInactiveTickTimerId;
++    // Folia end - profiler
++
+     public EntityType(EntityType.EntityFactory<T> factory, MobCategory spawnGroup, boolean saveable, boolean summonable, boolean fireImmune, boolean spawnableFarFromPlayer, ImmutableSet<Block> canSpawnInside, EntityDimensions dimensions, int maxTrackDistance, int trackTickInterval, FeatureFlagSet requiredFeatures) {
+        // Paper start
+         this(factory, spawnGroup, saveable, summonable, fireImmune, spawnableFarFromPlayer, canSpawnInside, dimensions, maxTrackDistance, trackTickInterval, requiredFeatures, "custom");
+@@ -332,6 +339,12 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+         this.passengerTickTimer = co.aikar.timings.MinecraftTimings.getEntityTimings(id, "passengerTick");
+         this.passengerInactiveTickTimer = co.aikar.timings.MinecraftTimings.getEntityTimings(id, "passengerInactiveTick");
+         // Paper end
++        // Folia start - profiler
++        this.tickTimerId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer("Entity Tick: " + id);
++        this.inactiveTickTimerId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer("Inactive Entity Tick: " + id);
++        this.passengerTickTimerId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer("Passenger Entity Tick: " + id);
++        this.passengerInactiveTickTimerId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer("Passenger Inactive Entity Tick: " + id);
++        // Folia end - profiler
+         this.builtInRegistryHolder = BuiltInRegistries.ENTITY_TYPE.createIntrusiveHolder(this);
+         this.factory = factory;
+         this.category = spawnGroup;
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index f9641a54b2d1f2eed2a48323cfa6cdd67dafdf00..0ff6764c747ee6258ab9d722b48c24f0ddb2afdf 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -226,6 +226,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         return this.getCurrentWorldData().getLocalPlayers();
+     }
+     // Folia end - region ticking
++    // Folia start - profiler
++    public final int tickTimerId;
++    // Folia end - profiler
+ 
+     protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, RegistryAccess iregistrycustom, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - Async-Anti-Xray - Pass executor
+         this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot
+@@ -318,6 +321,9 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         this.minSection = io.papermc.paper.util.WorldUtil.getMinSection(this);
+         this.maxSection = io.papermc.paper.util.WorldUtil.getMaxSection(this);
+         // Paper end - optimise collisions
++        // Folia start - profiler
++        this.tickTimerId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer(" Tick World: " + resourcekey.location().toString());
++        // Folia end - profiler
+     }
+ 
+     // Paper start
+@@ -1295,17 +1301,21 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+ 
+     protected void tickBlockEntities() {
++        final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+         gameprofilerfiller.push("blockEntities");
+         timings.tileEntityPending.startTiming(); // Spigot
+         final io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = ((ServerLevel)this).getCurrentWorldData(); // Folia - regionised ticking
+         regionizedWorldData.seTtickingBlockEntities(true); // Folia - regionised ticking
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY_PENDING); try { // Folia - profiler
+         regionizedWorldData.pushPendingTickingBlockEntities(); // Folia - regionised ticking
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY_PENDING); } // Folia - profiler
+         List<TickingBlockEntity> blockEntityTickers = regionizedWorldData.getBlockEntityTickers(); // Folia - regionised ticking
+         timings.tileEntityPending.stopTiming(); // Spigot
+ 
+         timings.tileEntityTick.startTiming(); // Spigot
++        profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY_TICK); try { // Folia - profiler
+         // Spigot start
+         // Iterator iterator = this.blockEntityTickers.iterator();
+         int tilesThisCycle = 0;
+@@ -1336,6 +1346,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             }
+         }
+         blockEntityTickers.removeAll(toRemove); // Folia - regionised ticking
++        } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY_TICK); } // Folia - profiler
+ 
+         timings.tileEntityTick.stopTiming(); // Spigot
+         regionizedWorldData.seTtickingBlockEntities(false); // Folia - regionised ticking
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntityType.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntityType.java
+index 2c1bc515468e2ba99d463021758fb72ef160fbe9..93cc5523a1c3637bf4f04ff4ef0f8ef6e1050a59 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntityType.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntityType.java
+@@ -78,10 +78,17 @@ public class BlockEntityType<T extends BlockEntity> {
+         }
+ 
+         Type<?> type = Util.fetchChoiceType(References.BLOCK_ENTITY, id);
+-        return Registry.register(BuiltInRegistries.BLOCK_ENTITY_TYPE, id, builder.build(type));
++        return Registry.register(BuiltInRegistries.BLOCK_ENTITY_TYPE, id, builder.build(type, id)); // Folia - profiler
+     }
+ 
+     public BlockEntityType(BlockEntityType.BlockEntitySupplier<? extends T> factory, Set<Block> blocks, Type<?> type) {
++        // Folia start - profiler
++        this(factory, blocks, type, "custom");
++    }
++    public final int tileEntityTimingId;
++    public BlockEntityType(BlockEntityType.BlockEntitySupplier<? extends T> factory, Set<Block> blocks, Type<?> type, String id) {
++        this.tileEntityTimingId = ca.spottedleaf.leafprofiler.LProfilerRegistry.GLOBAL_REGISTRY.getOrCreateTimer("Tile Entity Tick: " + id);
++        // Folia end - profiler
+         this.factory = factory;
+         this.validBlocks = blocks;
+         this.dataType = type;
+@@ -126,7 +133,12 @@ public class BlockEntityType<T extends BlockEntity> {
+         }
+ 
+         public BlockEntityType<T> build(Type<?> type) {
+-            return new BlockEntityType<>(this.factory, this.validBlocks, type);
++            // Folia start - profiler
++            return this.build(type, "custom");
++        }
++        public BlockEntityType<T> build(Type<?> type, String id) {
++            return new BlockEntityType<>(this.factory, this.validBlocks, type, id);
++            // Folia end - profiler
+         }
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index c474dec43f4c46421cdabc1154e22a3b269b0f11..f5a613ab1bb999a359a54de5314b14e8ed7cebc2 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -1186,11 +1186,14 @@ public class LevelChunk extends ChunkAccess {
+                 BlockPos blockposition = this.blockEntity.getBlockPos();
+ 
+                 if (LevelChunk.this.isTicking(blockposition)) {
++                    final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
++                    final int timerId = this.blockEntity.getType().tileEntityTimingId; // Folia - profiler
+                     try {
+                         ProfilerFiller gameprofilerfiller = LevelChunk.this.level.getProfiler();
+ 
+                         gameprofilerfiller.push(this::getType);
+                         this.blockEntity.tickTimer.startTiming(); // Spigot
++                        profiler.startTimer(timerId); try { // Folia - profiler
+                         BlockState iblockdata = LevelChunk.this.getBlockState(blockposition);
+ 
+                         if (this.blockEntity.getType().isValid(iblockdata)) {
+@@ -1200,6 +1203,7 @@ public class LevelChunk extends ChunkAccess {
+                             this.loggedInvalidBlockState = true;
+                             LevelChunk.LOGGER.warn("Block entity {} @ {} state {} invalid for ticking:", new Object[]{LogUtils.defer(this::getType), LogUtils.defer(this::getPos), iblockdata});
+                         }
++                        } finally { profiler.stopTimer(timerId); } // Folia - profiler
+ 
+                         gameprofilerfiller.pop();
+                     } catch (Throwable throwable) {
+diff --git a/src/main/java/net/minecraft/world/ticks/LevelTicks.java b/src/main/java/net/minecraft/world/ticks/LevelTicks.java
+index f3df9c9b6cff85565514f990597f3fe53652812c..860124fdafa8abc280039cbd7cf7968106920b24 100644
+--- a/src/main/java/net/minecraft/world/ticks/LevelTicks.java
++++ b/src/main/java/net/minecraft/world/ticks/LevelTicks.java
+@@ -255,6 +255,12 @@ public class LevelTicks<T> implements LevelTickAccess<T> {
+     }
+ 
+     private void runCollectedTicks(BiConsumer<BlockPos, T> ticker) {
++        // Folia start - profiler
++        io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler().addCounter(
++            ca.spottedleaf.leafprofiler.LProfilerRegistry.BLOCK_OR_FLUID_TICK_COUNT,
++            (long)this.toRunThisTick.size()
++        );
++        // Folia end - profiler
+         while(!this.toRunThisTick.isEmpty()) {
+             ScheduledTick<T> scheduledTick = this.toRunThisTick.poll();
+             if (!this.toRunThisTickSet.isEmpty()) {