Commit Graph

259 Commits

Author SHA1 Message Date
Spottedleaf
f15f1ceab5 Fix some bugs in ThreadedTicketLevelPropagator
First, when a section update is stolen, the thread that acquires
the stolen update should remove the update from the update queue
before returning to mark it as completed and allow other threads
waiting on the update to continue. This fixes a deadlock issue
with section updates.

Fix incorrect decrease queue resize. Previously, it attempted
to resize the _increase_ queue, which is the wrong queue.

Use ALL_DIRECTIONS_BITSET for every decrease queue direction bitset
as decrease propagation cancellation due to neighbour values exceeding
the target decrease value cause some neighbour directions to not
be checked, which causes the final update grid to be incorrect.
2023-05-15 21:29:38 -07:00
Spottedleaf
ed61eb315e Fix infinite loop in ChunkBasedPriorityTask#queue
We must attempt to synchronise when the returned queue is null
so that we can get a correct queue result or return false due to
the reference counter being released, or even to throw an exception
when the queue is null but the reference counter is not released.
2023-05-15 20:46:30 -07:00
Spottedleaf
1128810029 Always recalculate light list on protochunk deserialize
I noticed during my stress testing that the total size of the
light list was far too large, which indicates many duplicates.
For me, this caused many GC problems which made stress testing
harder.

It turns out, it was possible for the light list recalculation
logic to occur _and_ the addition of the light list data from
the NBT data. Since there is no logic to de-duplicate this list,
every chunk load would re-add all light sources into the light
list and the light list would grow uncontrollably.

Since the recalculation logic would often run, I have
decided to solve this by discarding the data on disk and always
just calculating the list from the chunk data alone. Additionally,
I have applied an optimization from Vanilla 1.20 to avoid
searching sections without light sources by first checking the
palette for possible block sources.

Now my stress tests do not have issues with GC at all.
2023-05-15 20:37:29 -07:00
Spottedleaf
94b1400a81 Optimise recalcBlockCounts() for empty sections
In 1.18, every chunk section is initialised to a non-null value
and recalcBlockCounts() is invoked for each section.
However, in a standard world, most sections are empty. In such cases,
recalcBlockCounts() would iterate over ever position - even though
the block data would all be air. To avoid this, we skip
searching the section unless the palette indicates there _could_ be
a non-air block state or non-empty fluid state.

Chunk loading initially showed that recalcBlockCounts() over
sections with a ZeroBitStorage data to to take ~20% of the process,
now it takes <1%.
2023-05-15 20:30:16 -07:00
Spottedleaf
22085eae15 Properly cancel chunk load tasks that were not scheduled
Since the chunk load task was not scheduled, the entity/poi load
task fields will not be set, but the task complete counter
will not be adjusted. Thus, the chunk load task will not complete.

To resolve this, detect when the entity/poi tasks were not scheduled
and decrement the task complete counter in such cases.
2023-05-15 12:27:19 -07:00
Spottedleaf
7595ff6bb2 Mark POI/Entity load tasks as completed before releasing scheduling lock
It must be marked as completed during that lock hold since the
waiters field is set to null. Thus, any other thread attempting
a cancellation will fail to remove from waiters. Also, any
other thread attempting to cancel may set the completed field
to true which would cause accept() to fail as well.

Completion was always designed to happen while holding the
scheduling lock to prevent these race conditions. The code
was originally set up to complete while not holding the
scheduling lock to avoid invoking callbacks while holding the
lock, however the access to the completion field was not
considered.

Resolve this by marking the callback as completed during the
lock, but invoking the accept() function after releasing
the lock. This will prevent any cancellation attempts to be
blocked, and allow the current thread to complete the callback
without any issues.
2023-05-15 11:42:31 -07:00
Spottedleaf
80af54eeda Synchronize PaperPermissionManager
Since multiple regions can exist, there are concurrent accesses
in this class. To prevent deadlock, the monitor is not held
when recalculating permissions, as Permissable holds its own
lock.

This fixes CMEs originating from this class.
2023-05-15 11:00:49 -07:00
Spottedleaf
051ec0dd65 Fix concurrenct access to lookups field in RegistryOps
The concurrent access occurs on the Netty IO threads when
serializing packets. Thus, it seems it was an oversight of
the implementator of this function as there are typically
more than one Netty IO thread.

Fixes https://github.com/PaperMC/Folia/issues/11
2023-05-15 00:26:56 -07:00
Spottedleaf
31b5b1575b Use coordinate-based locking to increase chunk system parallelism
A significant overhead in Folia comes from the chunk system's
locks, the ticket lock and the scheduling lock. The public
test server, which had ~330 players, had signficant performance
problems with these locks: ~80% of the time spent ticking
was _waiting_ for the locks to free. Given that it used
around 15 cores total at peak, this is a complete and utter loss
of potential.

To address this issue, I have replaced the ticket lock and scheduling
lock with two ReentrantAreaLocks. The ReentrantAreaLock takes a
shift, which is used internally to group positions into sections.
This grouping is neccessary, as the possible radius of area that
needs to be acquired for any given lock usage is up to 64. As such,
the shift is critical to reduce the number of areas required to lock
for any lock operation. Currently, it is set to a shift of 6, which
is identical to the ticket level propagation shift (and, it must be
at least the ticket level propagation shift AND the region shift).

The chunk system locking changes required a complete rewrite of the
chunk system tick, chunk system unload, and chunk system ticket level
propagation - as all of the previous logic only works with a single
global lock.

This does introduce two other section shifts: the lock shift, and the
ticket shift. The lock shift is simply what shift the area locks use,
and the ticket shift represents the size of the ticket sections.
Currently, these values are just set to the region shift for simplicity.
However, they are not arbitrary: the lock shift must be at least the size
of the ticket shift and must be at least the size of the region shift.
The ticket shift must also be >= the ceil(log2(max ticket level source)).

The chunk system's ticket propagator is now global state, instead of
region state. This cleans up the logic for ticket levels significantly,
and removes usage of the region lock in this area, but it also means
that the addition of a ticket no longer creates a region. To alleviate
the side effects of this change, the global tick thread now processes
ticket level updates for each world every tick to guarantee eventual
ticket level processing. The chunk system also provides a hook to
process ticket level changes in a given _section_, so that the
region queue can guarantee that after adding its reference counter
that the region section is created/exists/wont be destroyed.

The ticket propagator operates by updating the sources in a single ticket
section, and propagating the updates to its 1 radius neighbours. This
allows the ticket updates to occur in parallel or selectively (see above).
Currently, the process ticket level update function operates by
polling from a concurrent queue of sections to update and simply
invoking the single section update logic. This allows the function
to operate completely in parallel, provided the queue is ordered right.
Additionally, this limits the area used in the ticket/scheduling lock
when processing updates, which should massively increase parallelism compared
to before.

The chunk system ticket addition for expirable ticket types has been modified
to no longer track exact tick deadlines, as this relies on what region the
ticket is in. Instead, the chunk system tracks a map of
lock section -> (chunk coordinate -> expire ticket count) and every ticket
has been changed to have a removeDelay count that is decremented each tick.
Each region searches its own sections to find tickets to try to expire.

Chunk system unloading has been modified to track unloads by lock section.
The ordering is determined by which section a chunk resides in.
The unload process now removes from unload sections and processes
the full unload stages (1, 2, 3) before moving to the next section, if possible.
This allows the unload logic to only hold one lock section at a time for
each lock, which is a massive parallelism increase.

In stress testing, these changes lowered the locking overhead to only 5%
from ~70%, which completely fix the original problem as described.
2023-05-14 19:46:24 -07:00
Jason
9bd857dabc
Undo making JavaPlugin#logger field public (see PaperMC/Paper#9125) (#76) 2023-05-14 18:10:49 -07:00
Spottedleaf
10a11c3712 Do not access POI data for lodestone compass
Instead, we can just check the loaded chunk's block position for
the lodestone block, as that is at least safe enough for the light
engine compared to the POI access. This should make it safe for
off-region access.

Fixes https://github.com/PaperMC/Folia/issues/60
2023-05-13 17:30:55 -07:00
Spottedleaf
47105ea28e Break redstone on top of trap doors early
This logic hooks into the neighbour update which should be invoked
as a result of redstone powering the trap door.
2023-05-01 18:28:54 -07:00
Spottedleaf
b97116b7b2 Skip worldstate access when waking players up during data deserialization
In general, worldstate read/write is unacceptable during
data deserialization and is racey even in Vanilla. But in Folia,
some accesses may throw and as such we need to fix this directly.

Fixes https://github.com/PaperMC/Folia/issues/57
2023-04-23 07:50:43 -07:00
Spottedleaf
3a95485043 Block reading in-world tile entities on worldgen threads
The returned TE may be in the world, in which case it is unsafe
for the current thread to modify or access its contents.

Fixes https://github.com/PaperMC/Folia/issues/52
2023-04-23 07:50:42 -07:00
Spottedleaf
dddaab9bbd Prevent block updates in non-loaded or non-owned chunks
This is to prevent block physics from tripping thread checks by
far exceeding the bounds of the current region. While this does
add explicit block update suppression techniques, it's better
than the server crashing.
2023-04-17 19:51:21 -07:00
Spottedleaf
ce49776448 Add more debugging information to chunk sending
Perform thread checks on the chunk send and warn when the
world is mismatched. I suspect that the world mismatches for
an unknown reason, but need to confirm it to chase it down.
2023-04-17 15:37:16 -07:00
Spottedleaf
25e0cbdae4 Rework some parts of the player chunk loader
Change overview:
- Rework limiting
- Remove mid tick updates
- Introduce consistency checks

The old limiting logic used an intervalled counter, but
did not account for possible slight changes in mid tick
invoke rate as it relied heavily on mid-tick logic. Due to
the removal of mid tick updates, it is now important that
the logic functions correctly no matter what rate it is invoked
at. The new logic directly tracks the last update time and
allocates an amount based proportional on the rate targetted,
which makes the logic call rate independent.

The removal of mid tick updates is done to eliminate recursive
call risk, and to additionally reduce the lock pressure on the
chunk system by grouping chunk loads onto one part of the tick
rather than spreading it out. The limiting rework should ensure
that this does not negatively affect rates, but it will decrease
the perceived smoothness of chunk generation/loading at low rates.

Introduce more consistency checks such as correct tick thread
and ticking-after-removal checks. Also, perform checks during the player
chunk loader tick to avoid updating potentially removed
players during the tick.
The checks are primarily made to try to hunt down a bug that
is causing the player chunk loader to double send a chunk
to a player.
2023-04-10 17:51:21 -07:00
Spottedleaf
ad70ddfc20 Lag compensate block breaking
Due to TPS catchup being removed, a lost tick will always
affect block breaking.

Additionally, constant low TPS would affect block breaking
in an intrusive manner to the user when there is no need
for that to occur.
2023-04-10 14:16:16 -07:00
Spottedleaf
105f6d6a21 Adjust CB async teleport dismount behavior
The expected behavior is that the entity is only dismounted
_if_ the teleport takes place, not regardless of whether
the teleport takes place.

To adhere to the expected behavior, we need to create a new teleport
flag so that the NMS teleportAsync can perform the dismount.
2023-04-08 19:16:10 -07:00
Spottedleaf
c9ded2de1c Add entity/player/chunk counters to /tps
Required to add some basic hacks to expose a regionstats object
in the TickRegions data class, but this ensures that the retrieval
is thread-safe and could possibly support other data exposure
for async reads.

Additionally, since DecimalFormat is not thread-safe we need
to use ThreadLocals to instantiate them. Change the format
as well to use commas to separate groups of digits when
formatting large numbers so they are easier to read.
For example, 1000 becomes 1,000.
2023-04-08 18:44:37 -07:00
Spottedleaf
4431a66c12 Make CB Entity async teleport dismount entities being teleported
This preserves behavior with the older API that did
dismount the entity before teleporting

Fixes https://github.com/PaperMC/Folia/issues/36
2023-04-08 16:56:30 -07:00
Spottedleaf
d34fb878bb Always send untrack chunk packets
Vanilla inserted the alive check so that dead players
could see the chunks around them, but in Folia we do not
remove dead players so chunks will still load for them.

This prevents the client from having chunks in memory it
should not.
2023-04-03 22:50:00 -07:00
Spottedleaf
774141dfb1 Fix mob entity inventory loss when switching dimensions
The inventory was being cleared by removing the entity
from the world, but Folia changed the remove to be
before the entity copy which caused the new entity
to have a cleared inventory. Fix this by creating
a post-dimension copy callback that will clear
the inventory of the old entity.

Fixes https://github.com/PaperMC/Folia/issues/29
2023-04-03 22:14:42 -07:00
Spottedleaf
445613b931 Note world as well when a region fails to tick or execute tasks
Should always include the world if we're including the center
position
2023-04-03 21:26:19 -07:00
Spottedleaf
f8a17538e6 Fix destroying beehive without any players nearby throwing an exception
If the player moves out of range by the time the block is destroyed,
then the exception would throw and remove the player from the world

Additionally, when players fail to tick instead of removing
the player from the world, kick them to prevent a limbo state
2023-04-03 21:26:16 -07:00
Spottedleaf
4b0c614847 Calculate correct redstone offset when merging regions
It should be offset = to - from, not from - to. This should
fix redstone freezing randomly when merging regions.

Fixes https://github.com/PaperMC/Folia/issues/35
2023-04-03 19:33:42 -07:00
Spottedleaf
6d18e8e9b6 Make uses of SimpleDateFormat thread-safe
Turns out, the utility is not thread-safe to use for whatever
reason. So, we need to use ThreadLocal to create instances
per thread.
2023-04-03 18:41:09 -07:00
Spottedleaf
33d2aa8cf7 Make sign update executor use the EntityScheduler
The MinecraftServer executor will throw, and thanks
to CompletableFuture's awful exception handling
the exception was not logged or handled. Add
exception handling as well.

Fixes https://github.com/PaperMC/Folia/issues/27
2023-04-01 07:24:36 -07:00
Spottedleaf
7072994557 Acquire scheduling lock in NewChunkHolder#onFullChunkLoadChange
It modifies data that should be held by the lock: pending
chunk status
2023-04-01 00:53:27 -07:00
Spottedleaf
700d3c580c Always process specialCaseUnload during ticket level updates
It is not guaranteed that ticket levels are updated, so we need to
to move the logic so that it always runs whether or not tickets
update.
2023-03-31 21:20:53 -07:00
Spottedleaf
76b06a1260 Do not call getGameTime when portalling Villagers
The code to stop all brain tasks is required to pass the current
game time to the tasks it stops. But, when a villager is being
portalled, the copied entity does not have any running tasks. So,
we can simply return early before invoking getGameTime if there
are no running tasks.

Fixes https://github.com/PaperMC/Folia/issues/23
2023-03-31 20:48:20 -07:00
Spottedleaf
3f377072d8 Make move event location update use teleportAsync
Additionally, make the teleportAsync call immediately teleport
if the current caller owns the entity.

Fixes https://github.com/PaperMC/Folia/issues/18
2023-03-31 19:13:19 -07:00
Jake Potrebic
9c8863a490
Fix enchant command feedback messages (#22)
* Fix enchant command feedback messages
2023-03-31 18:25:55 -07:00
Jake Potrebic
508a6688e5
Fix 2 incorrect threading checks (#17)
* Fix 2 incorrect threading checks

* Fix bad catcher methods, fix missing async catcher

---------

Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
2023-03-31 17:15:16 -07:00
Jason
fbf832bc05
Log traces of tick threads that fail to shut down (#10)
* Log traces of threads that fail to shut down in SchedulerThreadPool
2023-03-31 16:51:55 -07:00
Noah van der Aa
ed7a5c57f4
fix: fix build number check in version fetcher (#16) 2023-03-30 14:13:55 -07:00
Riley Park
f3e6529d49 Notify users that Timings cannot be enabled on Folia 2023-03-29 19:41:21 -07:00
Riley Park
00864ac5b1 Update Upstream (PaperMC/Paper@cbcdfd03e7) 2023-03-29 19:41:15 -07:00
Spottedleaf
f34a20c36a Fix incorrect error handling in off-main chunk load task
Now that there is no on-main task, the completion logic
for the status task is completed with the results passed
by the off-main task. Thus, the chunk system saw a non-null
throwable and assumed a fatal crash. The old on-main task
did not pass the throwable through in this case, which allowed
the chunk to re-generate.

Fixes https://github.com/PaperMC/Folia/issues/7
2023-03-29 17:11:39 -07:00
Spottedleaf
749480c7ec Fix getCenterChunk not returning the center chunk
Before, it returned the center chunk section. Also, now instead
of approximating the center chunk from the allocated sections,
actually retrieve all chunks inside the region directly.
2023-03-29 16:58:33 -07:00
Spottedleaf
b3e1b06c07 Fix compilation of TestPluginMeta
Needed to implement isFoliaSupported()
2023-03-29 14:33:48 -07:00
Spottedleaf
9998ecd60d Make ActivationRange#activateEntities use non-checked getEntities
We can do this because we thread-check the entities retrieved,
we want to do this because a large activation range may violate
thread-checks
2023-03-29 14:22:15 -07:00
Owen1212055
32f79c415e Support paper plugin meta marking plugins as Folia supported 2023-03-29 14:12:30 -07:00
Spottedleaf
f42c61aba6 Folia Metrics page
https://bstats.org/plugin/server-implementation/Folia/18084
2023-03-29 12:53:55 -07:00
Jason Penilla
fca2eba2f8
fix build 2023-03-29 10:18:38 -07:00
Spottedleaf
7de5c541b3 Nerf default tick thread allocation
Allocates too many threads by default
2023-03-29 08:12:27 -07:00
Josh Roy
88167d59d2
Add Server#isGlobalTickThread (#5) 2023-03-28 18:59:19 -07:00
Spottedleaf
108dc2358b Use chunk coords for thread check for CraftWorld#getHighestBlockYAt
Not block coords
2023-03-28 16:13:18 -07:00
Spottedleaf
1c5e9be7fd Force prevent moving into unloaded chunks
Not safe to allow this anymore
2023-03-28 15:59:41 -07:00
Spottedleaf
d113346b6d Fix isTickThread(world, blockX, blockZ)
Need to convert the Z to chunk, not block...

Also throw for CraftPlayer#teleport and friends
2023-03-27 20:29:16 -07:00
Spottedleaf
1175350400 Fix failure to initialise CraftWorld
Directly access spawn category limits rather than go through
the method
2023-03-27 16:06:19 -07:00
Josh Roy
5fa0556869
Use longs for scheduler delays/periods (#4) 2023-03-25 21:48:28 -07:00
Spottedleaf
75e3cdbc61 Rebase fixups 2023-03-25 16:29:07 -07:00
Spottedleaf
6df8272abf Deprecate bukkit scheduler
Every method on that should basically throw, so the API should
reflect that
2023-03-25 16:27:55 -07:00
Spottedleaf
66c77fb573 Add more thread checks to API
Most of the World methods, and for updating captured TEs
2023-03-25 16:26:54 -07:00
Spottedleaf
c435aaae96 Add world checks to retrieval of regionised world data
This is to mirror behavior of RegionizedData's world check.
2023-03-25 15:27:50 -07:00
Spottedleaf
7eea12b9e4 Kenny momentos
Random newline?
2023-03-25 11:55:44 -07:00
Nassim Jahnke
3c62932250
Fix player disconnect call in PlayerList removAll 2023-03-25 19:44:11 +01:00
Nassim Jahnke
5e7b4f0185
Fix tests by removing them 2023-03-25 19:06:35 +01:00
Nassim Jahnke
836dc75b65
Replace Vector with Position in isOwnedByCurrentRegion methods
Closes #3
2023-03-25 18:50:36 +01:00
Nassim Jahnke
8d15f3e23d
Add methods taking world, chunkX, chunkZ to RegionScheduler 2023-03-25 18:40:20 +01:00
Nassim Jahnke
dfc157075a
Renames for consistency 2023-03-25 00:22:47 +01:00
Spottedleaf
6a5fff3caa Make ClickCallbackProviderImpl thread-safe
Can no longer process tasks from the main thread like that anymore,
it just needs to be concurrent.
2023-03-23 07:55:26 -07:00
Spottedleaf
d5b837c457 Make Damagecommand safe, and remove RideCommand 2023-03-23 07:36:44 -07:00
Spottedleaf
4c183bf960 Fix compile 2023-03-23 07:22:57 -07:00
Spottedleaf
c7fbdd87d2 Update to 1.19.4
Patches applied, but not yet checked compile.
2023-03-23 06:55:09 -07:00
Spottedleaf
e3a299c5ce Lowercase project names
Make JMP happy
2023-03-23 04:53:58 -07:00
Spottedleaf
50ad6c3131 New scheduler API
Now, entity/global/location schedulers implement a generic run,
runDelayed, and runAtFixedRate methods that provide a ScheduledTask
value that can be used to interact with the scheduled task.

Add also an async task scheduler that implements the same methods,
except the delays/periods are in time and not ticks, as the scheduler
is independent of the server tick process.

Additionally, throw on some unimplemented APIs now.
2023-03-23 02:51:04 -07:00
Spottedleaf
0da953539b Disable mid-tick task execution
Mid-tick task execution acquires the ticket lock at least,
which can possibly be a significant performance bottleneck
at a high tick thread + region count. This change should reduce
the impact from scaling the region threads, but is not a fix
to the underlying issue.
2023-03-20 02:48:16 -07:00
Spottedleaf
106a4affdc Suppress entire CB passenger events if the entity is not valid
The event is not being called, so the checks will not do
anything. We need to bypass the checks so that we do not trip
the thread check.
2023-03-19 17:41:24 -07:00
Spottedleaf
7e948a6179 Add global region scheduler
This will allow plugins to safely execute commands or perform
other global tick thread data modification.
2023-03-19 16:43:34 -07:00
Spottedleaf
cbf8108d4e Make max concurrent logins patch use maxJoinsPerTick config
This patch performed perfectly to handle the test server,
so it can stay.
2023-03-19 14:58:52 -07:00
Spottedleaf
0911c7a58a Remove patches specific for stream
Specifically, the /msg and /me command removal and the operator
only chat. Additionally, remove the TPA commands.
2023-03-19 14:53:06 -07:00
Spottedleaf
ee737050a0 Add thread checks for CraftEntity#getHandle
Also resolve some issues found by this change.

Currently, the player handle checks are disabled.
2023-03-19 14:48:37 -07:00
Spottedleaf
a980944815 Regionise RedStoneWireBlock#shouldSignal
Global state used to update redstone, so it should be regionised.
2023-03-12 20:55:52 -07:00
Spottedleaf
6fe75ab068 Erase mob target in getTarget if it is not in the current region
This will prevent access to the target's position or data.
2023-03-12 15:36:05 -07:00
Spottedleaf
3aeb021748 Make PoiCompetitorScan region-safe
We implement it by ensuring that if the entity is not nearby
the job site, they automatically lose.
2023-03-12 15:25:06 -07:00
Spottedleaf
cf72543628 Rebase fixups 2023-03-12 15:04:00 -07:00
Spottedleaf
a9a885ad00 Resolve concurrent access to ticket state
The concurrent access occurred in the region merge/split logic,
as it did not own the ticket lock. To resolve this, we simply
make the ticket add/remove acquire the read lock of
the region lock.
2023-03-12 15:00:38 -07:00
Spottedleaf
518b2d5dec Fix zero radius tasks being recognized as infinite
Fixes parallelism loss from spawn entity chunk status
2023-03-12 00:51:43 -08:00
Spottedleaf
0a11f6aa1f Do not execute infinite radius task in parallel when pushing tasks
By definition, it should not execute in parallel with anything.
2023-03-12 00:17:44 -08:00
Spottedleaf
3bc5341531 Make specialCaseUnload global state
With region state, it may be modified concurrently while
only holding the region lock. Need to figure out a solution
for the ticket state as well.
2023-03-11 23:28:34 -08:00
Spottedleaf
9561a53e7a Log exceptions in ThreadedRegioniser explicitly
I suspect something called these methods, they threw and then
the error was hidden by some completablefuture somewhere.
2023-03-11 12:56:43 -08:00
Spottedleaf
a80cdafae9 Make uncaught exceptions in tick thread shut down the server 2023-03-11 12:36:37 -08:00
Spottedleaf
3f2b83c35a Make SaplingBlock.treeType a thread-local
Now it is accessed concurrently
2023-03-11 06:27:35 -08:00
Spottedleaf
9e835221b9 Update new bee position before adding to beehive
This will ensure the thread check from discard does not fail
2023-03-11 06:14:05 -08:00
Spottedleaf
760de0a276 Move region center calculation into try-catch
Sometimes a region is empty, but only when the threaded regioniser
crashes. So, it should not prevent shutdown.

Additionally, only remove pending teleports after setting the
current region.
2023-03-11 05:46:20 -08:00
Spottedleaf
0fa5f339f2 Do not allow players to interact with entities outside the current region 2023-03-11 05:38:11 -08:00
Spottedleaf
d2a5acba4a Do not allow players to interact with blocks outside of their region 2023-03-11 05:16:10 -08:00
Spottedleaf
4af9f6c889 Do not allow players to destroy blocks that are not owned 2023-03-11 05:10:34 -08:00
Spottedleaf
4cffea6652 Read cancelled field while holding region lock
This will prevent a race condition where the region is cancelled
and immediately re-scheduled, and where this all happens while
the tick thread is blocking on tryMarkTicking.
2023-03-10 20:46:58 -08:00
Spottedleaf
f6d776697b Fix kicking player when they die on a vehicle with instant respawn
The respawn logic apparently can fire before the death is broadcasted
2023-03-10 20:11:08 -08:00
Spottedleaf
e1ad1b1d91 No longer give everyone access to /tps
Everyone had access to /tps for the private tests, but we cannot
trust everyone to use it responsibly for the public test
(i.e revealing coordinates of all logged in players).
2023-03-10 00:19:40 -08:00
Spottedleaf
d258d32393 Add chunk system throughput counters to /tps 2023-03-10 00:18:12 -08:00
Spottedleaf
8625606b3d Fix crash if player disconnects during login stage 2023-03-09 21:17:18 -08:00
Spottedleaf
a9d01f9b4f Max pending logins
Should help hold the floodgates on launch
2023-03-09 21:04:10 -08:00
Spottedleaf
bbee4310fe Fix fishing rods throwing exceptions
Need to move setOwner after the position update, as the thread-check
will fall back to position
2023-03-09 20:45:32 -08:00
Spottedleaf
5cbf898ca1 Stream mode
Disable chat and /msg and /me for non-ops so that the server is
safe to stream
2023-03-09 20:45:32 -08:00
Spottedleaf
950216171d Do not let projectiles travel into chunks not owned by current region
Otherwise, the thread checks for moving the entity into the new
entity chunk section would throw and cause the projectile to
be deleted.
2023-03-08 20:15:22 -08:00
Spottedleaf
ef515cc6f5 Consider non-owned chunks in entity movement as unloaded
This should prevent entities from moving into areas not owned
by the current region.
2023-03-08 19:44:01 -08:00
Spottedleaf
afd678cab6 Fall back to position check if the entity has a null entity callback
In the case that the entity has a null callback, it means the
entity has not been added to the world - so, we should treat
it the same as entity#isRemoved.
2023-03-08 19:38:50 -08:00
Spottedleaf
deae156e59 Make Level#getBlockEntity return null immediately if not tickthread
Otherwise, the world data will be null and we will NPE. The
function is supposed to return null for off-thread access,
anyways.
2023-03-08 17:40:28 -08:00
Spottedleaf
74f665b6f5 Fix compilation 2023-03-07 20:06:08 -08:00
Spottedleaf
b00a16a66d Fix command label placeholder in usage for /tps
Only <command> gets replaced with the provided label
2023-03-07 17:34:45 -08:00
Spottedleaf
68b20e0acc Add API for checking ownership of region by position/entity
This may be useful for plugins which want to perform operations
over large areas outside of the buffer zone provided by the
regionaliser, as it is not guaranteed that anything outside
of the buffer zone is owned. Then, the plugins may use
the schedulers depending on the result of the ownership
check.
2023-03-07 14:44:37 -08:00
Spottedleaf
386bcd1094 Make ServerLevel#areChunksLoadedForMove also check region ownership
We do not want players to move into chunks that are not owned
by the current region
2023-03-07 13:31:59 -08:00
Spottedleaf
0e4358fb7e Make Player#kickPlayer function asynchronously
We have made disconnect() mt-safe, so there is no need for
this check anymore.
2023-03-07 13:22:53 -08:00
Spottedleaf
7af86e656d Do not schedule keepalive fail kick to main
There is no main thread to schedule to, and I've already
make disconnect() handle off-region kicks safely.
2023-03-07 13:19:29 -08:00
Spottedleaf
99429cee37 Make plugin tickets no longer sync load the chunk
This is to prevent any thread-check from failing. Note that
ticket additions are mt-safe.

Additionally, add more thread checks.
2023-03-07 13:13:31 -08:00
Spottedleaf
2ccfc8efc0 Add RegionisedServerInitEvent
This event allows plugins to perform synchronous operations before
any region will tick. Plugins will not have to worry about the
possibility of a region ticking in parallel while listening
to the event.
2023-03-07 13:06:11 -08:00
Spottedleaf
f86bc13d22 Make tpdeny prompt show /tpadeny instead of /tpaccept
As it should be showing
2023-03-07 13:03:20 -08:00
Spottedleaf
71a4219ab6 Make sure /tps includes global region in total util percent
While we expect the util from the global region to be around 0.0,
it doesn't mean it always will be. So, include it.
2023-03-07 12:51:23 -08:00
Spottedleaf
8fcf959ee3 Fix various World chunk methods
- Add thread check for loadChunk
- Make isChunkGenerated use the region task queue to schedule
  to "main"
- Don't complete async chunk future if not in the owning thread
  for the chunk
2023-03-06 14:27:02 -08:00
Spottedleaf
7ca8feff63 Log delayed world init
Nothing ticks until this is done, so it should be logged.
2023-03-06 14:04:08 -08:00
Spottedleaf
5c4d65efb8 Require plugins to be explicitly marked as Folia supported
Plugins must add "folia-supported: true" to their plugin.yml
otherwise the server will refuse to load them.

Since Folia is a major breakage for plugins, the vast majority
of plugins will not function correctly on Folia. To prevent
user confusion from this, we will refuse to load the plugin
and provide a log indicating why - which will be much
more helpful than some random error log caused by
a breakage.
2023-03-06 14:03:17 -08:00
Spottedleaf
4e7205d401 Change entity scheduler API to use Runnables
The generics pose a problem, and the parameter passed to the
Consumer is not needed in API.

Additionally, stop trying to cancel Bukkit scheduler tasks on
plugin disable as the Bukkit scheduler does not work.
2023-03-06 12:57:29 -08:00
Spottedleaf
490b8f5182 Add logo 2023-03-06 02:43:32 -08:00
Spottedleaf
e6d60da06f Halt chunk systems before saving chunks for all worlds
This is to ensure that chunks are not progressing in other worlds
while saving
2023-03-05 12:51:23 -08:00
Spottedleaf
43d0469e36 Initial README documentation
First draft
2023-03-04 20:27:36 -08:00
Spottedleaf
282ded3b44 Add some scheduling API 2023-03-04 13:13:23 -08:00
Spottedleaf
8ffa40246a Fix NPE in treeFinished()
tryPushTasks returns null when there are no tasks, not
an empty list.
2023-03-03 16:46:03 -08:00
Spottedleaf
04b28a65ca Fix mob spawning
We should only iterate over the local region's entities, not the
global entity list to set up the spawner state, as everything else
about the spawner state (player count / chunk count) is regionised.
Additionally, move the last spawner state to regionised state so that
paper mobcaps command functions as expected.
2023-03-03 15:58:43 -08:00
Spottedleaf
f9327302d8 Make ServerLevel#onTrackingEnd map data access thread-safe
We need to synchronise on the map data object and on the
cache, as is done everywhere else for access of such data
2023-03-02 23:39:55 -08:00
Spottedleaf
bb3f8a4aea Process player chunk loader mid tick at the start of tick
Additionally, process ticket updates as well if either
the mid tick logic did anything or whether we processed
any chunk tasks.

We process the mid tick logic at the start to be consistent
with the inbetween task execution logic (which is not implemented),
and we process ticket updates to ensure that any full status changes
are processed from chunk tasks.
2023-03-02 23:31:59 -08:00
Spottedleaf
b42537ed02 Cache whether region files do not exist
The repeated I/O of creating the directory for the regionfile
or for checking if the file exists can be heavy in
when pushing chunk generation extremely hard - as each chunk gen
request may effectively go through to the I/O thread.
2023-03-02 23:26:47 -08:00
Spottedleaf
bc07c9f31f Fix radius aware executor softlock
The softlock would occur when a dependency tree finished executing
all of its task and searched for the highest dependency tree
to queue tasks from, only to have that such tree be filled
with purged tasks. Because it would select an empty
tree to pull tasks from, it would not select another
tree to execute tasks from as this logic is done after a task
is executed.
2023-03-01 22:22:24 -08:00
Spottedleaf
9443d3ad35 Only attempt to respawn/cancel ender dragon if current region owns 0,0
The only tick thread allowed to touch the dragon fight state is
the one that owns 0,0
2023-03-01 20:10:34 -08:00
Spottedleaf
ac079d0691 Use Folia repo in version checker
Want this to work after it goes public
2023-03-01 19:16:40 -08:00
Spottedleaf
093b1e5394 Fix several issues, mostly saving pending teleporting entities
The place/portal async function now track entities that have been
removed from the world but have not teleported. When the server
shuts down, these entities will have their passenger tree restored
and re-added to the entity slices at the location they were teleporting to,
or in the case of portals that did not run placeAsync yet,
the location they entered the portal on. This should ensure that
for regular teleports that the entity is placed at its correct
target location, and for portalling to ensure that either
the entity is placed at the portal entrace location (where
they entered) or the portal destination. In any case,
the entity is preserved in a location and will survive
the shutdown.

Additionally, move player saving until after the worlds save. This
is to ensure that the save logic is performed only after
all teleportations have completed.

Fix some other misc issues as well:
 - Fix double nether portal creation by checking if a portal exists again
   before creating it, fixing a race condition where two entites would portal
   and neither would see that the other created a portal.
 - Make all remove ticket add an unknown ticket.
   In general this behavior is better since it means that unloads will only
   ever occur at the next tick, rather than during the tick logic. Thus,
   there will be no cases where a chunk is unloaded unexpectedly.
 - Do not use fastFloor for calculating chunk position from block position
   It is not going to return a good value outside of [-1024, 1024]
 - Always perform mid tick update for ticking regionised player chunk loader
   If no entities were loaded, no chunks were loaded, and nothing else -
   the logic would not have otherwise ran. This fixed some rare cases of
   chunks never loading for players after logging in.
2023-03-01 19:12:31 -08:00
Spottedleaf
85c9fb622a Improve thread-safety of ownsRaid
It should null check the position and retrieve it only once.
2023-02-28 06:41:08 -08:00
Spottedleaf
30d90b4700 Make raids thread-safe
We don't need to worry about synchronisation for saving data,
as that is currently only done by the shutdown thread - after
all regions stop ticking.
2023-02-28 06:33:34 -08:00
Spottedleaf
36675a1b9f Make map data thread-safe to access
We can just synchronise on all of the map data accesses, but
this means we need to be careful about ensuring that no
sync loads occur, otherwise we could block other threads for
long periods of time.
2023-02-27 08:37:47 -08:00
Spottedleaf
19fd3efaa6 Increase parallelism for neighbour writing chunk statuses
Namely, everything after FEATURES. By creating a dependency
chain indicating what chunks are in use, we can safely
schedule completely independent tasks in parallel. This
will allow the chunk system to scale beyond 10 threads
per world.

Currently this patch needs some more testing.
2023-02-26 23:45:21 -08:00
Spottedleaf
5a4351d3b6 Improve thread-safety of combat tracker
The simple solution is that we ignore entities/positions that are not
in the current region. Making retrieval of items in inventory
thread-safe is not going to happen.
2023-02-24 00:23:10 -08:00
Spottedleaf
9b824e6406 Fix player chunk loader behaving poorly when limits are low
Need to use ceil() so that it always allows at least 1 addition
for the 50ms case.
2023-02-24 00:03:00 -08:00
Spottedleaf
b772012778 Make the StructureCheck class MT-Safe
This is so that it may be accessed concurrently
from many regions.

Additionally, make sure it does not leak memory by limiting
the number of entries it will cache.
2023-02-23 23:35:30 -08:00
Spottedleaf
6d922d4b48 Implement player sleep status / night skip
Now, all of the sleep status changes are pushed to the global
tick thread. Had to modify the wake up all players routine
to use the task scheduler to ensure the player is woken up
on the right region context.

Fix erroring while crashing on the global tick thread due to
region field being null.
2023-02-23 20:48:49 -08:00
Spottedleaf
f7e2fe2267 Force disable timings
Need a new profiler system with region threading
2023-02-23 20:13:44 -08:00
Spottedleaf
2474482685 Remove the remains of per-player mob spawns
Now, the spawning should be running Vanilla logic; except
that it is calculated per region (which is what per player
was effectively achieving anyways).
2023-02-23 20:07:56 -08:00
Spottedleaf
256f68d149 Regionise skip hopper event fields 2023-02-23 19:34:00 -08:00
Spottedleaf
fd7901d0f1 Implement TPA system for test server
Will be removed later once this is all public.

Fixed many issues with teleporting players on vehicles
while in the same region.

Additionaly, make sure dead players are dismounted - as
this logic was previously done by remove.

Re-add regiontodo.txt
2023-02-23 18:42:20 -08:00
Spottedleaf
fa05f7830c Implement BlockEntity#updateTicks
Because game time is now on the global tick thread, we no longer
need adjustments for any block entity. But, just in case we do
updateTicks functions now.
2023-02-23 12:52:39 -08:00
Spottedleaf
5f6b82862f Make BlockEntity#IGNORE_TILE_UPDATES a thread local
Ensures regions do not step over each other
2023-02-23 12:33:43 -08:00
Spottedleaf
18cac6b26e Use Folia comments in threaded regions patch
Other patches planned to be rebased
2023-02-23 08:35:07 -08:00
Spottedleaf
62c1166ee5 Initial commit 2023-02-23 08:13:45 -08:00
Jason Penilla
b19eb28a37
Update 2022-12-13 14:27:38 -07:00
Jason Penilla
aedd5067fd
Update upstream 2022-04-21 20:36:03 -07:00
Jason Penilla
74b34eec95
Lowercase project names and exclude paper-api from paper-mojangapi 2021-12-02 20:58:35 -08:00
Jason Penilla
ad960f72e1
Update upstream 2021-12-02 00:00:38 -08:00
Jason Penilla
53dbd2bc9c
Update upstream & paperweight to 1.2.0 2021-11-16 21:27:00 -08:00