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 function QH_Timeslice_Yield()
  35   if coroutine_running then
  36     -- Check if we've run our alotted time
  37     yield_ct = yield_ct + 1
  38     if GetTime() > coroutine_stop_time then
  39       local sti = debugstack(2, 5, 5) -- string.gsub(debugstack(2, 1, 1), "\n.*", "")
  40       if qh_loud_and_annoying and GetTime() > coroutine_stop_time + 0.0015 then
  41         print(yield_ct, (GetTime() - coroutine_stop_time) * 1000, "took too long", sti, "------ from", last_stack, "------")
  42       end
  43
  44       -- As a safety, reset stop time to 0.  If somehow we fail to set it next time,
  45       -- we'll be sure to yield promptly.
  46       coroutine_stop_time = 0
  47       coroutine.yield()
  48       last_stack = sti
  49       yield_ct = 0
  50     end
  51   end
  52 end
  53
  54 function QH_Timeslice_Bonus(quantity)
  55   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %d bonus", quantity)) end
  56   coroutine_route_pass = coroutine_route_pass + quantity
  57 end
  58
  59 local prioritize = {
  60   init = {100},
  61   criteria = {10},
  62   lzw = {-5},
  63   compress = {-8, 5},
  64   routing = {-10},
  65 }
  66
  67 function QH_Timeslice_Add(workfunc, name)
  68   QuestHelper: Assert(workfunc)
  69   QuestHelper: Assert(name)
  70   local priority = prioritize[name] and prioritize[name][1] or 0
  71   local sharding = prioritize[name] and prioritize[name][2] or 1
  72   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s added (%s, %d)", name, tostring(workfunc), priority)) end
  73   local ncoro = coroutine.create(workfunc)
  74   QuestHelper: Assert(ncoro)
  75   table.insert(coroutine_list, {priority = priority, sharding = sharding, name = name, coro = ncoro, active = true})
  76 end
  77
  78 function QH_Timeslice_Toggle(name, flag)
  79   --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s toggled to %s", name, tostring(not not flag))) end
  80   for _, v in pairs(coroutine_list) do
  81     if v.name == name then v.active = flag end
  82   end
  83 end
  84
  85 local started = false
  86
  87 function QH_Timeslice_Doneinit()
  88   if not started then
  89     if debug_output then
  90       QuestHelper:TextOut("Done with initialization step")
  91     end
  92
  93     QuestHelper.loading_main = nil
  94     QuestHelper.loading_flightpath = nil
  95     QuestHelper.loading_preroll = nil
  96
  97     collectgarbage("collect") -- fuuuuuck youuuuuuuu
  98   end
  99
 100   started = true
 101 end
 102
 103 local startacu = GetTime()
 104 local totalacu = 0
 105 local lacu = 0
 106
 107 --[[function qhtacureset()
 108   startacu = GetTime()
 109   totalacu = 0
 110   lacu = 0
 111 end]]
 112
 113 function QH_Timeslice_Work(time_used, time_this_frame, bonus_time)
 114   -- There's probably a better way to do this, but. Eh. Lua.
 115   coro = nil
 116   key = nil
 117   for k, v in pairs(coroutine_list) do
 118     if v.active then
 119       --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
 120       if (not v.sharding or bit.mod(time(), v.sharding) == 0) and (not coro or (v.priority > coro.priority)) then
 121         coro = v
 122         key = k
 123       end
 124     end
 125   end
 126
 127   if coro then
 128     --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s running", coro.name)) end
 129
 130     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.
 131       coroutine_list[key] = nil
 132       QuestHelper: Assert(coroutine.status(coro.coro) ~= "dead")
 133     end
 134
 135     local slicefactor = (QuestHelper_Pref.hide and 0.01 or (QuestHelper_Pref.perf_scale_2 * math.min(coroutine_route_pass, 5)))
 136     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
 137     local time_to_use = slicefactor * time_this_frame * 0.075 -- We want to use 7.5% of the system CPU
 138     if InCombatLockdown() then time_to_use = time_to_use / 5 end
 139     local coroutine_intended_stop_time = GetTime() + time_to_use
 140     coroutine_stop_time = coroutine_intended_stop_time - coroutine_time_exceeded - time_used + bonus_time
 141     coroutine_route_pass = coroutine_route_pass - 5
 142     if coroutine_route_pass <= 0 then coroutine_route_pass = 1 end
 143
 144     local start = GetTime()
 145     local state, err = true, nil -- default values for "we're fine"
 146
 147     totalacu = totalacu + math.max(0, coroutine_stop_time - start)
 148     --[[if lacu + 0.1 < totalacu then
 149       lacu = totalacu
 150       print(string.format("%f realtime, %f runtime, %f%%", start - startacu, totalacu, (totalacu / (start - startacu)) * 100))
 151     end]]
 152     --print(string.format("ttutf %f, tu %f, bt %f, wut %f lolwut %f", time_to_use, time_used, bonus_time, QuestHelper_Pref.perf_scale_2, slicefactor))
 153
 154     if start < coroutine_stop_time then -- We don't want to just return on failure because we want to credit the exceeded time properly.
 155       coroutine_running = true
 156       state, err = coroutine.resume(coro.coro)
 157       coroutine_running = false
 158     end
 159     local total = GetTime() - start
 160
 161     local coroutine_this_cycle_exceeded = GetTime() - coroutine_intended_stop_time -- may be either positive or negative
 162     coroutine_time_exceeded = min(coroutine_time_exceeded + coroutine_this_cycle_exceeded, slicefactor * 2e-3 * 5)  -- honestly, waiting for more than five frames to recover from a stutter is just dumb
 163
 164     coroutine_time_used[coro.name] = (coroutine_time_used[coro.name] or 0) + total
 165
 166     if not state then
 167       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s errored", coro.name)) end
 168       QuestHelper_ErrorCatcher_ExplicitError(true, err, "", string.format("(Coroutine error in %s)\n", coro.name))
 169     end
 170
 171     QuestHelper: Assert(coro.coro)
 172     if coroutine.status(coro.coro) == "dead" then
 173       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s complete", coro.name)) end
 174       coroutine_list[key] = nil
 175     end
 176   else
 177     if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: no available tasks")) end
 178   end
 179 end
 180
 181 function QH_Timeslice_Increment(quantity, name)
 182   local an = "(nc) " .. name
 183   coroutine_time_used[an] = (coroutine_time_used[an] or 0) + quantity
 184 end