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_panic_time = 0
  11 local coroutine_list = {}
  12 local coroutine_route_pass = 1
  13
  14 local coroutine_verbose = false
  15
  16 local coroutine_time_used = {}
  17 local coroutine_power_up = GetTime()
  18
  19 local coroutine_time_exceeded = 0
  20
  21 function QH_Timeslice_DumpPerf()
  22   local sortable = {}
  23   for k, v in pairs(coroutine_time_used) do
  24     table.insert(sortable, {name = k, amount = v})
  25   end
  26   table.sort(sortable, function(a, b) return a.name < b.name end)
  27   for _, v in pairs(sortable) do
  28     QuestHelper:TextOut(string.format("%s: %f", QuestHelper:HighlightText(v.name), v.amount))
  29   end
  30   QuestHelper:TextOut(string.format("%s: %f", QuestHelper:HighlightText("poweron"), GetTime() - coroutine_power_up))
  31 end
  32
  33 local last_stack = nil
  34 local yield_ct = 0
  35 function QH_Timeslice_Yield()
  36   if coroutine_running then
  37     -- Check if we've run our alotted time
  38     yield_ct = yield_ct + 1
  39     if GetTime() > coroutine_stop_time then
  40       -- As a safety, reset stop time to 0.  If somehow we fail to set it next time,
  41       -- we'll be sure to yield promptly.
  42       coroutine_stop_time = 0
  43
  44       local sti = debugstack(2, 5, 5) -- string.gsub(debugstack(2, 1, 1), "\n.*", "")
  45       if qh_loud_and_annoying and GetTime() > coroutine_panic_time then
  46         print(yield_ct, "took too long", last_stack, "------", sti)
  47       end
  48       coroutine.yield()
  49       last_stack = sti
  50       yield_ct = 0
  51     end
  52   end
  53 end
  54
  55 function QH_Timeslice_Bonus(quantity)
  56   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %d bonus", quantity)) end
  57   coroutine_route_pass = coroutine_route_pass + quantity
  58 end
  59
  60 local prioritize = {
  61   init = {100},
  62   criteria = {10},
  63   lzw = {-5},
  64   compress = {-8, 5},
  65   routing = {-10},
  66 }
  67
  68 function QH_Timeslice_Add(workfunc, name)
  69   QuestHelper: Assert(workfunc)
  70   QuestHelper: Assert(name)
  71   local priority = prioritize[name] and prioritize[name][1] or 0
  72   local sharding = prioritize[name] and prioritize[name][2] or 1
  73   if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s added (%s, %d)", name, tostring(workfunc), priority)) end
  74   local ncoro = coroutine.create(workfunc)
  75   QuestHelper: Assert(ncoro)
  76   table.insert(coroutine_list, {priority = priority, sharding = sharding, name = name, coro = ncoro, active = true})
  77 end
  78
  79 function QH_Timeslice_Toggle(name, flag)
  80   --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s toggled to %s", name, tostring(not not flag))) end
  81   for _, v in pairs(coroutine_list) do
  82     if v.name == name then v.active = flag end
  83   end
  84 end
  85
  86 local started = false
  87
  88 function QH_Timeslice_Doneinit()
  89   if not started then
  90     if debug_output then
  91       QuestHelper:TextOut("Done with initialization step")
  92     end
  93
  94     QuestHelper.loading_main = nil
  95     QuestHelper.loading_flightpath = nil
  96     QuestHelper.loading_preroll = nil
  97
  98     collectgarbage("collect") -- fuuuuuck youuuuuuuu
  99   end
 100
 101   started = true
 102 end
 103
 104 function QH_Timeslice_Work()
 105   -- There's probably a better way to do this, but. Eh. Lua.
 106   coro = nil
 107   key = nil
 108   for k, v in pairs(coroutine_list) do
 109     if v.active then
 110       --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
 111       if (not v.sharding or bit.mod(time(), v.sharding) == 0) and (not coro or (v.priority > coro.priority)) then
 112         coro = v
 113         key = k
 114       end
 115     end
 116   end
 117
 118   if coro then
 119     --if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s running", coro.name)) end
 120
 121     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.
 122       coroutine_list[key] = nil
 123       QuestHelper: Assert(coroutine.status(coro.coro) ~= "dead")
 124     end
 125
 126     local slicefactor = (QuestHelper_Pref.hide and 0.01 or (QuestHelper_Pref.perf_scale * math.min(coroutine_route_pass, 5)))
 127     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
 128     local coroutine_intended_stop_time = GetTime() + 2e-3 * slicefactor
 129     coroutine_stop_time = coroutine_intended_stop_time - coroutine_time_exceeded
 130     coroutine_panic_time = coroutine_stop_time + 2e-3 * slicefactor
 131     coroutine_route_pass = coroutine_route_pass - 5
 132     if coroutine_route_pass <= 0 then coroutine_route_pass = 1 end
 133
 134     local start = GetTime()
 135     local state, err = true, nil -- default values for "we're fine"
 136     if start < coroutine_stop_time then -- We don't want to just return on failure because we want to credit the exceeded time properly.
 137       coroutine_running = true
 138       state, err = coroutine.resume(coro.coro)
 139       coroutine_running = false
 140     end
 141     local total = GetTime() - start
 142
 143     local coroutine_this_cycle_exceeded = GetTime() - coroutine_intended_stop_time -- may be either positive or negative
 144     coroutine_time_exceeded = coroutine_time_exceeded + coroutine_this_cycle_exceeded
 145
 146     coroutine_time_used[coro.name] = (coroutine_time_used[coro.name] or 0) + total
 147
 148     if not state then
 149       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s errored", coro.name)) end
 150       QuestHelper_ErrorCatcher_ExplicitError(true, err, "", string.format("(Coroutine error in %s)\n", coro.name))
 151     end
 152
 153     QuestHelper: Assert(coro.coro)
 154     if coroutine.status(coro.coro) == "dead" then
 155       if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: %s complete", coro.name)) end
 156       coroutine_list[key] = nil
 157     end
 158   else
 159     if coroutine_verbose then QuestHelper:TextOut(string.format("timeslice: no available tasks")) end
 160   end
 161 end
 162
 163 function QH_Timeslice_Increment(quantity, name)
 164   local an = "(nc) " .. name
 165   coroutine_time_used[an] = (coroutine_time_used[an] or 0) + quantity
 166 end