Topics

Admincraft•2mo ago

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬

Performance tips for plugins?

Hi, I made a plugin that drops heads as one of its features, but apparently the part of "adding the skin to the head" has terrible performance for something surprisingly simple. It's just get the item meta, set the skull owner and put it back. (and put it into the drops list) I made the report on the fly on my local pc (windows), so it's very likely that it affected the results. I made this code as an alternative, and while it gets good performance, it kinda looks horrible creating an async task and a sync one inside for each player death. Not sure if someone has a better tip for this, or if I it will be negligeable once on linux (I won't be able to test this on linux for a couple of days).

    private fun handleHeadDrops(event: PlayerDeathEvent) {
        if (Random.nextDouble() > RootConfig.HEAD.CHANCE) return
        val location = event.player.location
        val world = event.player.world
        Bukkit.getScheduler().runTaskAsynchronously(this.plugin) { _ ->
            val head = ItemStack(Material.PLAYER_HEAD)
            val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
            head.itemMeta = meta

            Bukkit.getScheduler().runTask(this.plugin) { _ ->
                val item = world.dropItem(location, head)
            }
        }
    }

    private fun handleHeadDrops(event: PlayerDeathEvent) {
        if (Random.nextDouble() > RootConfig.HEAD.CHANCE) return
        val location = event.player.location
        val world = event.player.world
        Bukkit.getScheduler().runTaskAsynchronously(this.plugin) { _ ->
            val head = ItemStack(Material.PLAYER_HEAD)
            val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
            head.itemMeta = meta

            Bukkit.getScheduler().runTask(this.plugin) { _ ->
                val item = world.dropItem(location, head)
            }
        }
    }

This probably will sound silly, but I also don't know how the bukkit scheduler works internally, so idk if it's literally a scheduler, with a separate single thread to run scheduled tasks, or if it creates a different new thread everytime something is scheduled. Report before: https://spark.lucko.me/wbbIOR4xc0 Report after adding the code above: https://spark.lucko.me/W9JAoVXoR9

spark is a performance profiler for Minecraft clients, servers, and proxies.

spark is a performance profiler for Minecraft clients, servers, and proxies.

Solution:

I really like to use coroutines, like this ```kotlin private fun handleHeadDrops_old(event: PlayerDeathEvent) { CoroutineScope(ioDispatcher).launch {...

Jump to solution

31 Replies

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Without the code above, it visually looks like the player stays alive for like half a second and then die. With the code, it just dies immediately. This is how it looked like before

    private fun handleHeadDrops_old(event: PlayerDeathEvent) {
        val head = ItemStack(Material.PLAYER_HEAD)
        val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
        head.itemMeta = meta
        event.drops.add(head)
    }

    private fun handleHeadDrops_old(event: PlayerDeathEvent) {
        val head = ItemStack(Material.PLAYER_HEAD)
        val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
        head.itemMeta = meta
        event.drops.add(head)
    }

TurboVadim•2mo ago

I don't really see any performance problems in the spark profile with the plugin Why do you even think that performance is terrible?

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Not like terrible, but on the client side looks like this, like you take half a second to die, and I'm the only player on the server I fear that if more players die at the same time, it will halt the server for a couple of seconds The report will look fine in general, but considering this it's just three lines, at least to me it looks like a lot in comparison to other parts of the code that do a lot more stuff and don't even appear in the report It will probably be more noticeable once it scales

TurboVadim•2mo ago

If you care mostly about code clarity while keeping some heavier functions asynchronous (at least partially), i can show you how do I deal with it, but not now, cause I rly need to sleep finally Understandable

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

dw, gn :very_nice:

Snow Kit•2mo ago

apparently 2x more time is spent on minimessage parsing for death messages than doing the skull stuff

No description

No description

TurboVadim•2mo ago

Ok, I'm here that's different function

Snow Kit•2mo ago

certainly is, but the improving the handling of minimessage deserialization would improve the performance of the plugin especially as both of them are called the same amount of times

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Yh, I also found that exceedingly weird, but I just shrug it as being windows (no async profiler), basically because the code is a single line (I split them in 3 to make it more readable) Not sure how can I improve that

No description

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Btw, you know how much those Bukkit.getScheduler().runTaskAsynchronously(...) can be abused? I saw some people just using them everywhere

Snow Kit•2mo ago

yeah, could be profiler bias, only way to check is test it on linux/mac

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

hi

Snow Kit•2mo ago

it runs in a thread pool, so it's probably fine

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

nice You think this code is fine? at least it looked very weird to me having nested schedulers And being called once everytime someone dies

Solution

TurboVadim•2mo ago

I really like to use coroutines, like this

private fun handleHeadDrops_old(event: PlayerDeathEvent) {
    CoroutineScope(ioDispatcher).launch {
        val head = ItemStack(Material.PLAYER_HEAD)
        val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
        head.itemMeta = meta
        withContext(bukkitDispatcher) {
            event.drops.add(head)
        }
    }
}

private fun handleHeadDrops_old(event: PlayerDeathEvent) {
    CoroutineScope(ioDispatcher).launch {
        val head = ItemStack(Material.PLAYER_HEAD)
        val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
        head.itemMeta = meta
        withContext(bukkitDispatcher) {
            event.drops.add(head)
        }
    }
}

TurboVadim•2mo ago

class BukkitDispatcher(private val plugin: Plugin) : AbstractBukkitDispatcher(plugin) {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        if (isFolia) {
            plugin.server.globalRegionScheduler.execute(plugin, block)
        } else {
            runFallback(block)
        }
    }
}

abstract class AbstractBukkitDispatcher(
    private val plugin: Plugin
) : CoroutineDispatcher() {
    protected fun runFallback(block: Runnable) {
        if (Bukkit.isPrimaryThread()) {
            block.run()
        } else {
            Bukkit.getScheduler().runTask(plugin, block)
        }
    }
}

class BukkitDispatcher(private val plugin: Plugin) : AbstractBukkitDispatcher(plugin) {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        if (isFolia) {
            plugin.server.globalRegionScheduler.execute(plugin, block)
        } else {
            runFallback(block)
        }
    }
}

abstract class AbstractBukkitDispatcher(
    private val plugin: Plugin
) : CoroutineDispatcher() {
    protected fun runFallback(block: Runnable) {
        if (Bukkit.isPrimaryThread()) {
            block.run()
        } else {
            Bukkit.getScheduler().runTask(plugin, block)
        }
    }
}

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Even with folia support I'll give it a try Thxxx

TurboVadim•2mo ago

And how is it going?

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Haven’t tested today Your variable ioDispatcher is this default dispatcher? Dispatchers.IO

    private fun handleHeadDrops(event: PlayerDeathEvent) {
        val location = event.player.location
        val world = event.player.world
        CoroutineScope(Dispatchers.IO).launch {
            val head = ItemStack(Material.PLAYER_HEAD)
            val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
            head.itemMeta = meta
            withContext(bukkitDispatcher) {
                val item = world.dropItem(location, head)
                if (RootConfig.HEAD.GLOW) {
                    item.isGlowing = true
                }
            }
        }
    }

    private fun handleHeadDrops(event: PlayerDeathEvent) {
        val location = event.player.location
        val world = event.player.world
        CoroutineScope(Dispatchers.IO).launch {
            val head = ItemStack(Material.PLAYER_HEAD)
            val meta = (head.itemMeta as SkullMeta).apply { owningPlayer = event.player }
            head.itemMeta = meta
            withContext(bukkitDispatcher) {
                val item = world.dropItem(location, head)
                if (RootConfig.HEAD.GLOW) {
                    item.isGlowing = true
                }
            }
        }
    }

TurboVadim•2mo ago

Yeah, it's Dispatchers.IO but with extended coroutines limit

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

https://spark.lucko.me/Ew8nCHLDKZ

spark is a performance profiler for Minecraft clients, servers, and proxies.

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

I'll compare both versions of the plugin in linux in a couple of days But so far seems like a solid alternative to try thx for your implementation!

TurboVadim•2mo ago

btw these two lines are the same function, so spark is wrong here

No description

ProGamingDk•2mo ago

literally says the name of two different functions tho

ProGamingDk•2mo ago

TurboVadim•2mo ago

MB, I still can't think of anything after being sick.

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Actually that handleInventory is one of the heavy functions I mentioned that should've appeared in the first reports, but only the head part did I'll see if tomorrow I can test on linux to discard being windows fault

TurboVadim•2mo ago

Sadly, you can't make some functions run outside of the main thread.

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Srry about the delay, I got completely distracted in other projects

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

https://spark.lucko.me/ZEKGkCVgRz

spark is a performance profiler for Minecraft clients, servers, and proxies.

𝐁𝐢𝐪𝐮𝐚𝐭𝐞𝐫𝐧𝐢𝐨𝐧𝐬OP•2mo ago

Finally made the report in a proper environment and now it has the expected performance impact, random and shuffle are indeed the most impactful, no traces of the $handleHeadDrops nor weird delay when dying, seems like it was a windows thing Thx for the tips!

Admincraft Join

12KMembers

View on Discord

Did you find this page helpful?