WoWInterface - Pattern to manage heavy operations

WoWInterface (https://www.wowinterface.com/forums/index.php)

- Lua/XML Help (https://www.wowinterface.com/forums/forumdisplay.php?f=16)

- - Pattern to manage heavy operations (https://www.wowinterface.com/forums/showthread.php?t=58916)

Pattern to manage heavy operations

Hello.

I'm planning on writing a piece of code that will process a lot of information and I'm afraid that this will freeze the users client. How can I avoid this situation?

Let's put it in an example:

Code:

local chunkSize = 100



function getNextChunk(currentPosition)

    -- return next chunk from huge table.

end



function processItem(data)

    -- Data is also a big table that will require several operations

end



function doIt(currentPosition, callback) 

    local nextChunk = getNextChunk(currentposition)

    if (not nextChunk) then

        return

    end



    local currentIndex = -1

    for id, data in pairs (nextChunk) do

        currentIndex = currentIndex + 1



        -- continue next chunk

        if (currentIndex ~= chunkSize) then

            callback(processItem(data))

        else

            -- process next chunk after sometime, using an async timer or OnUpdate?

            -- this is the part I'm missing

            return

        end

    end

end

Or perhaps instead of processing the table by chunks use a ticker or something like that and process 1 by 1?

Thanks!

you could use onupdate to process x items every frame or coroutines or a mix of both (that's what i do, throttling based on fps)

are you sure the issue isn't how you process (or even access) your data?

Hey sezz, thanks for your answer.

In the implementation I did the client freezes 1 second until the whole thing is done. Which is not so bad, but I wanted to do it properly so that doesn't happend at all. I know that TSM or other addons move more data than mine and they don't have those problems.

I honestly didn't know anything about coroutines. I'm going to read about it, but first I will try with the OnUpdate event. I haven't played enough with it, let's see what I can do.

Do you know of any site where they explain coroutines with a good example? I imagine they work as threads, right?

Ok, so I've been researching a little bit about OnUpdate + coroutines and I think I understand how to do it, basically I have to set the Script "OnUpdate" to call a method where I start my own coroutine. The coroutine will process an specific amount of data, based on time or number of items, and keep the state internaly. Once the coroutine is done, I set OnUpdate to nil so it stops calling the coroutine, and I clear its internal state to be reused. That should do it.

I'm going to implement a test to see how it goes.

This function takes a workload and chips away at it, moving to the next frame after a budgeted amount of time. The budget is set to 50% of the target FPS, or 50% of the current FPS (if there is no target).

Better alternatives might check after X iterations, or sample the frame rate at more than a single point and maybe average it out.

Lua Code:

--  Budgets 50% of target or current FPS to perform a workload. 
--  finished = start(workload, onFinish, onDelay)
--  Arguments:
--      workload        table       Stack (last in, first out) of functions to call.
--      onFinish        function?   Optional callback when the table is empty.
--      onDelay         function?   Optional callback each time work delays to the next frame.
--  Returns:
--      finished        boolean     True when finished without any delay; false otherwise.
local function start(workload, onFinish, onDelay)
    local maxDuration = 500/(tonumber(C_CVar.GetCVar("targetFPS")) or GetFrameRate())
    local startTime = debugprofilestop()
    local function continue()
        local startTime = debugprofilestop()
        local task = tremove(workload)
        while (task) do
            task()
            if (debugprofilestop() - startTime > maxDuration) then
                C_Timer.After(0, continue)
                if (onDelay) then
                    onDelay()
                end
                return false
            end
            task = tremove(workload)
        end
        if (onFinish) then
            onFinish()
        end
        return true
    end
    return continue()
end

And here is the testing code I used to make sure it works...

Lua Code:

-- Simple testing code
-- /sillyloop           Runs a brief atomic workload (same as /sillyloop 1)
-- /sillyloop 0         Runs an empty workload
-- /sillyloop 10000     Runs a long workload with 10000 parts
-- This overwrites existing workloads, so call /sillyloop to stop an ongoing workload
 
local workload = {}
 
local function sillyLoop()
    local x=1
    for i=1, 10000 do
        x = x+1+2+3+4+5+6+7+8+9
        x = x-1-2-3-4-5-6-7-8-9
        x = x/2/3/4/5/6/7/8/9
        x = x*i*2*3*4*5*6*7*8*9
    end
    
end
 
SlashCmdList["DEBUG_SILLYLOOP"] = function(msg)
    wipe(workload)
    for i=1, tonumber(msg) or 1 do
        workload[i] = sillyLoop
    end
    local overallStart = debugprofilestop()
    start(
        workload,
        function() print("done!") end,
        function() print(#workload.." remaining after "..("%.2d"):format(debugprofilestop()-overallStart)/1000) end
    )
end
SLASH_DEBUG_SILLYLOOP1 = "/sillyloop"

This is the code I wrote with your ideas:

Lua Code:

local Routine = {} do   
    function Routine:Init(getterItems, chunkSize)
        self.context, self.deadline = {}
        self.context.currentIndex = 1
        self.context.getterItems = getterItems 
        self.context.chunkSize = chunkSize
    end
 
    function Routine:Run(callback)
        if (not self.context) then
            return true
        end
        self.deadline = debugprofilestop() + 500/(tonumber(C_CVar.GetCVar("targetFPS")) or GetFrameRate() or 35)
 
        repeat
            local totalIndex = 1
            local chunkIndex = 1
            for key, value in pairs(self.context.getterItems()) do
                if (totalIndex >= self.context.currentIndex) then
                    if (chunkIndex == self.context.chunkSize) then
                        return false
                    end
                    
                    callback(self.context, key, value)
                    self.context.currentIndex = self.context.currentIndex + 1
                    chunkIndex = chunkIndex + 1
                end
                
                totalIndex = totalIndex + 1
            end
            
            self.context.finished = true
            return true
        until debugprofilestop() > self.deadline
    end
    
    function Routine:IsRunning()
        if self.context and not self.context.finished then
            return true
        end
        return false
    end
    
    function Routine:Reset()
        self.context = {}
    end
    
    function Routine:New(routine)
        routine = routine or {}
        setmetatable(routine, self)
        self.__index = self
        return routine
    end
end

And this is how I use it:

Lua Code:

local routine = Routine:New()
routine:Init(GetStuff, 100)
 
-- Using OnUpdate script
myFrame:SetScript("OnUpdate", function(self)
    local finished = routine:Run(function(state, key, value)
        doHeavyStuff(key, value)
    end)
    
    if (finished) then
        routine:Reset()
        self:SetScript("OnUpdate", nil)
    end
end);
 
-- Using a ticker if the frame is hidden
C_Timer.NewTicker(0.5, function(self)
    local finished = routine:Run(function(context, key, value)
        doHeavyStuff(key, value)
    end)
    
    if (finished) then
        routine:Reset()
        self:Cancel()
    end
end

So far this improves the performance a lot. It takes longer to finish, but I'm sure I can improve it changing the value of "state.chunkSize".

The issue I find with this code is that it loops through the table returned by GetStuff() several times and I don't see how to avoid it.

Thank you both!

I edited my post some time after originally writing it, as I now had time to log in and do some testing. See above for the updated code.

Thanks for the code DahkCeles.

I see that in your example in order to process the loop in chunks I will have to split it and add it to the workload array splitted. I like the way you calculate the duration, taking into account the FPS.

With this example I have more than enough to improve the performance.

Cheers.