timeslice.lua

   1 QuestHelper_File["timeslice.lua"] = "Development Version"
   2 QuestHelper_Loadtime["timeslice.lua"] = GetTime()
   3
   4 local debug_output = (QuestHelper_File["timeslice.lua"] == "Development Version")
   5
   6 -- Any non-local item here is part of an available public interface.
   7
   8 local coroutine_running = false
   9 local coroutine_stop_time = 0
  10 local coroutine_list = {}
  11 local coroutine_route_pass = 1
  12
  13 local coroutine_verbose = false
  14
  15 local coroutine_time_used = {}
  16 local coroutine_power_up = GetTime()
  17
  18 local coroutine_time_exceeded = 0
  19
  20 function QH_Timeslice_DumpPerf()
  21   local sortable = {}
  22   for k, v in pairs(coroutine_time_used) do
  23     table.insert(sortable, {name = k, amount = v})
  24   end
  25   table.sort(sortable, function(a, b) return a.name < b.name end)
  26   for _, v in pairs(sortable) do
  27     QuestHelper:TextOut(string.format("%s: %f", QuestHelper:HighlightText(v.name), v.amount))
  28   end
  29   QuestHelper:TextOut(string.format("%s: %f", QuestHelper:HighlightText("poweron"), GetTime() - coroutine_power_up))
  30 end
  31
  32 local last_stack = nil
  33 local yield_ct = 0
  34 local GetTime = GetTime
  35 local unyieldable = 0
  36 function QH_Timeslice_PushUnyieldable()
  37   unyieldable = unyieldable + 1
  38 end
  39 function QH_Timeslice_PopUnyieldable()
  40   unyieldable = unyieldable - 1
  41   QuestHelper: Assert(unyieldable >= 0)
  42 end
  43 function QH_Timeslice_Yield()
  44   if unyieldable > 0 then return end
  45   if coroutine_running then
  46     -- Check if we've run our alotted time
  47     yield_ct = yield_ct + 1
  48     if GetTime() > coroutine_stop_time then
  49       local sti = debugstack(2, 5, 5) -- string.gsub(debugstack(2, 1, 1), "\n.*", "")
  50       if qh_loud_and_annoying and GetTime() > coroutine_stop_time + 0.0015 then
  51         print(yield_ct, (GetTime() - coroutine_stop_time) * 1000, "took too long", sti, "------ from", last_stack, "------")
  52       end
  53
  54       -- As a safety, reset stop time to 0.  If somehow we fail to set it next time,
  55       -- we'll be sure to yield promptly.
  56       coroutine_stop_time = 0
  57       coroutine.yield()
  58       last_stack = sti
  59       yield_ct = 0
  60     end
  61   end
  62 end
  63
  64 function QH_Timeslice_Bonus(quantity)
  65   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %d bonus", quantity)) end
  66   coroutine_route_pass = coroutine_route_pass + quantity
  67 end
  68
  69 local prioritize = {
  70   preinit = {101},
  71   init = {100},
  72   criteria = {10},
  73   lzw = {-5},
  74   compress = {-8, 5},
  75   new_routing = {-10},
  76 }
  77
  78 local bumped_priority = {}
  79
  80 function QH_Timeslice_Add(workfunc, name)
  81   QuestHelper: Assert(workfunc)
  82   QuestHelper: Assert(name)
  83   local priority = prioritize[name] and prioritize[name][1] or 0
  84   local sharding = prioritize[name] and prioritize[name][2] or 1
  85   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s added (%s, %d)", name, tostring(workfunc), priority)) end
  86   local ncoro = coroutine.create(workfunc)
  87   QuestHelper: Assert(ncoro)
  88   table.insert(coroutine_list, {priority = priority, sharding = sharding, name = name, coro = ncoro, active = true})
  89 end
  90
  91 function QH_Timeslice_Toggle(name, flag)
  92   --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s toggled to %s", name, tostring(not not flag))) end
  93   for _, v in pairs(coroutine_list) do
  94     if v.name == name then v.active = flag end
  95   end
  96 end
  97
  98 local started = false
  99
 100 function QH_Timeslice_Doneinit()
 101   if not started then
 102     if debug_output then
 103       QuestHelper:TextOut("Done with initialization step")
 104     end
 105
 106     QuestHelper.loading_main = nil
 107     QuestHelper.loading_flightpath = nil
 108     QuestHelper.loading_preroll = nil
 109
 110     collectgarbage("collect") -- fuuuuuck youuuuuuuu
 111   end
 112
 113   started = true
 114 end
 115
 116 function QH_Timeslice_Bump(type, newpri)
 117   bumped_priority[type] = newpri
 118 end
 119 function QH_Timeslice_Bump_Reset(type)
 120   bumped_priority[type] = nil
 121 end
 122
 123 local startacu = GetTime()
 124 local totalacu = 0
 125 local lacu = 0
 126
 127 --[[function qhtacureset()
 128   startacu = GetTime()
 129   totalacu = 0
 130   lacu = 0
 131 end]]
 132
 133 local thrown_away_excess = 0
 134 local total_used = 0
 135
 136 function QH_Timeslice_Work(time_used, time_this_frame, bonus_time, verbose)
 137   -- There's probably a better way to do this, but. Eh. Lua.
 138   QuestHelper: Assert(unyieldable == 0)
 139
 140   local coro = nil
 141   local key = nil
 142   local cpri = nil
 143   for k, v in pairs(coroutine_list) do
 144     if v.active then
 145       --if v.sharding then QuestHelper:TextOut(string.format("%d mod %d is %d, %s", time(), v.sharding, bit.mod(time(), v.sharding), tostring(bit.mod(time(), v.sharding) == 0))) end
 146       local pri = bumped_priority[v.name] or v.priority
 147       if (not v.sharding or bit.mod(time(), v.sharding) == 0) and (not coro or (pri > cpri)) then
 148         coro = v
 149         key = k
 150         cpri = pri
 151       end
 152     end
 153   end
 154
 155   if coro then
 156     --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s running", coro.name)) end
 157
 158     if coroutine.status(coro.coro) == "dead" then   -- Someone was claiming to get an infinite loop with this. I don't see how it's possible, but this should at least fix the infinite loop.
 159       coroutine_list[key] = nil
 160     end
 161       QuestHelper: Assert(coroutine.status(coro.coro) ~= "dead")
 162
 163     local slicefactor = (QuestHelper_Pref.hide and 0.01 or (QuestHelper_Pref.perf_scale_2 * math.min(coroutine_route_pass, 5)))
 164     if not started then slicefactor = 5 * QuestHelper_Pref.perfload_scale * math.min(coroutine_route_pass, 5) end  -- the init process gets much higher priority so we get done with it faster
 165     local time_to_use = slicefactor * time_this_frame * 0.075 -- We want to use 7.5% of the system CPU
 166     if InCombatLockdown() then time_to_use = time_to_use / 5 end
 167     local coroutine_intended_stop_time = time_to_use
 168     coroutine_stop_time = coroutine_intended_stop_time - coroutine_time_exceeded - time_used + bonus_time
 169     coroutine_route_pass = coroutine_route_pass - 5
 170     if coroutine_route_pass <= 0 then coroutine_route_pass = 1 end
 171
 172     if verbose then
 173       print(string.format("time_to_use %f, time_already_used %f, bonus_time %f, coroutine_time_exceeded %f, total_time_to_use %f", time_to_use, time_used, bonus_time, coroutine_time_exceeded, coroutine_stop_time))
 174       print(string.format("thrown_away_excess %f, used %f, maxi %f", thrown_away_excess, total_used, slicefactor * 0.075 * 5))
 175     end
 176
 177     local start = GetTime()
 178     coroutine_stop_time, coroutine_intended_stop_time = coroutine_stop_time + start, coroutine_intended_stop_time + start
 179     local state, err = true, nil -- default values for "we're fine"
 180
 181     totalacu = totalacu + math.max(0, coroutine_stop_time - start)
 182     --[[if lacu + 0.1 < totalacu then
 183       lacu = totalacu
 184       print(string.format("%f realtime, %f runtime, %f%%", start - startacu, totalacu, (totalacu / (start - startacu)) * 100))
 185     end]]
 186
 187     if start < coroutine_stop_time then -- We don't want to just return on failure because we want to credit the exceeded time properly.
 188       coroutine_running = true
 189       QuestHelper: Assert(unyieldable == 0)
 190       state, err = coroutine.resume(coro.coro)
 191       QuestHelper: Assert(unyieldable == 0)
 192       coroutine_running = false
 193     end
 194     local stop = GetTime()
 195
 196     local total = stop - start
 197     local coroutine_this_cycle_exceeded = stop - coroutine_intended_stop_time -- may be either positive or negative
 198
 199     local origcte = coroutine_time_exceeded + coroutine_this_cycle_exceeded
 200     coroutine_time_exceeded = min(origcte, slicefactor * 0.075 * 5)  -- honestly, waiting for more than five seconds to recover from a stutter is just dumb
 201     thrown_away_excess = thrown_away_excess + (origcte - coroutine_time_exceeded)
 202     total_used = total_used + total
 203
 204     coroutine_time_used[coro.name] = (coroutine_time_used[coro.name] or 0) + total
 205
 206     if not state then
 207       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s errored", coro.name)) end
 208       QuestHelper_ErrorCatcher_ExplicitError(true, err, "", string.format("(Coroutine error in %s)\n", coro.name))
 209     end
 210
 211     QuestHelper: Assert(coro.coro)
 212     if coroutine.status(coro.coro) == "dead" then
 213       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s complete", coro.name)) end
 214       coroutine_list[key] = nil
 215     end
 216   else
 217     if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: no available tasks")) end
 218   end
 219 end
 220
 221 function QH_Timeslice_Increment(quantity, name)
 222   local an = "(nc) " .. name
 223   coroutine_time_used[an] = (coroutine_time_used[an] or 0) + quantity
 224 end