--[[ !!PerfLog - performance diagnostics for WoW 1.12 (Lua 5.0) The addon loads first (the "!!" prefix) so that it can: * attribute every frame to the addon that created it; * wrap the OnEvent / OnUpdate / OnShow / OnHide scripts of every frame to measure the CPU time and Lua memory allocated by each handler; * track FPS, frame times, hitches, garbage collection, latency... Everything is written to \CustomData\PerfLog____.log through WriteCustomFile (nampower). Without nampower it falls back to the SavedVariables (WTF\Account\\SavedVariables\!!PerfLog.lua). Open the file with Viewer\PerfLogViewer.html (drag and drop). Format: one record per line, tab-separated fields. S key value session header A addon enabled loaded addon list C cvar value graphics / nampower cvars R id owner script name source declaration of a profiled handler T t dur frames maxMs n33 n50 n100 lat memKB thrKB allocKB gc freedKB luaMs selfMs combat loading group children bgSec gcMs H t frameMs luaMs allocKB gc freedKB spikes events combat allocTop gcMs With ducielperf >= 0.4.1 (S gcStats "exact"): allocKB = bytes allocated, gc = number of collections (T) / 1 if any (H), freedKB = bytes freed, gcMs = GC time, all exact over the tick / frame. Otherwise (S gcStats "gcinfo estimate") they are guessed from gcinfo() drops as before, and gcMs is 0 (T) / "-" (H). P t window id key calls ms maxMs allocKB gc G t window bucket allocKB allocCount exact allocations per addon (ducielperf DLL) X t frames frameMs then for fileRead decompress fileFind modelOpen modelProcess textureLoad textureDone packet gc: Ms Calls Bytes (gcBytes = freed) engine counters over the tick (ducielperf), same t as its T line K t addon KB Lua memory held by each loaded addon (ClassicAPI), at each loading screen and on /perflog mem; followed by "M t mem ..." M t boss_start / boss_kill (s) / boss_wipe (s) BigWigs fights; the profile window (P/E/G/B) is closed at each, so windows line up with fights B t window results largeResults largeKB liveBuffers strings built through luaL_Buffer in the window, those over 512 bytes and their size (ducielperf >= 0.5.0 builds them garbage-free; S strbuf says if active) Y hitchT frameMs [name|ms|calls|KB ...] engine counters of a hitch's slow frame (ducielperf), counters >= 0.5 ms only, t = the H line's t E t window event fires dispatches M t type text markers (combat, zone, loading screens, background, /perflog mark) F t ms bytes cost of one disk write Allocation tracking (G lines, allocTop): with ducielperf >= 0.3.0 the DLL counts every Lua allocation and charges it to the addon whose code is running (including allocations made inside game API calls). Buckets are addon folder names, "FrameXML", "GlueXML", "(engine)" (no Lua running) and "(unknown)" (no source file, e.g. inline XML handlers). allocTop = the 3 biggest allocators since the previous second ("name|KB;..."), "-" if not available. /perflog alloc on|off (on by default when the DLL is present) Engine counters (X / Y lines, ducielperf >= 0.4.0): time, calls and bytes of disk/MPQ reads, decompression, file lookups, model and texture loading and server packets, per tick and for the slow frame of each hitch. Times are inclusive and overlap: never add them up. Freeze watchdog: when the DLL writes a report to Logs\ducielperf_freezes.log, PerfLog adds an "M t dp_freeze " marker. PerfLog never switches the watchdog or the counting off. /perflog fs on|off (PerfLog reading the counters; on by default) Background window: when WoW is not the active window it throttles itself to a fixed low frame rate (about 4 FPS here, i.e. ~260 ms frames). Those frames are not hitches. A run of bgRun frames that are all >= bgMinMs, within bgTol of each other and with almost no Lua time is treated as "background": the hitches of the run are dropped, a bg_start / bg_end marker is written, and the T line gets the number of seconds spent in background (bgSec). ]] local ADDON_NAME = "!!PerfLog" local VERSION = "1.8.0" local GetTime, gcinfo, pairs, type, tostring, pcall = GetTime, gcinfo, pairs, type, tostring, pcall local format, gsub, sfind = string.format, string.gsub, string.find local tconcat, tsort, floor = table.concat, table.sort, math.floor ------------------------------------------------------------------------ -- Configuration ------------------------------------------------------------------------ local DEFAULTS = { enabled = true, -- write the log profile = true, -- profile handlers hitchMs = 60, -- a frame longer than this = hitch spikeMs = 1, -- handler calls >= this are kept to explain a hitch window = 30, -- seconds between two profile dumps tick = 1, -- seconds between two T lines flush = 10, -- seconds between two disk writes scanBatch = 100, -- max frames inspected per rendered frame scanBudgetMs = 1, -- max scanner time per rendered frame (ms) rescan = 20, -- seconds between two full scanner passes bgMinMs = 150, -- background: frames at least this long... bgRun = 3, -- ...this many in a row... bgTol = 0.15, -- ...each within 15% of the previous one alloc = true, -- per-addon allocation tracking (ducielperf DLL, if present) frameStats = true, -- engine frame counters (ducielperf DLL, if present) memSnap = true, -- Lua memory per addon at each loading screen (ClassicAPI) } local cfg = {} for k, v in pairs(DEFAULTS) do cfg[k] = v end local PROF = true -- profiling active (read from the config at ADDON_LOADED) local SCRIPTS = { "OnEvent", "OnUpdate", "OnShow", "OnHide" } local NSCRIPTS = 4 local PROFILED = { OnEvent = true, OnUpdate = true, OnShow = true, OnHide = true } local function Print(msg) if DEFAULT_CHAT_FRAME then DEFAULT_CHAT_FRAME:AddMessage("|cff33ff99PerfLog|r " .. tostring(msg)) end end local function San(s) s = tostring(s or "?") s = gsub(s, "[\t\r\n]", " ") return s end ------------------------------------------------------------------------ -- High resolution clock ------------------------------------------------------------------------ local clock, CLOCK_NAME if type(debugprofilestop) == "function" then if type(debugprofilestart) == "function" then debugprofilestart() end clock = debugprofilestop CLOCK_NAME = "debugprofilestop" else clock = function() return GetTime() * 1000 end CLOCK_NAME = "GetTime" end local function MeasureClockResolution() local best local changes = 0 local a = clock() for i = 1, 300000 do local b = clock() if b ~= a then local d = b - a if d > 0 and (not best or d < best) then best = d end a = b changes = changes + 1 if changes >= 30 then break end end end return best or -1 end local T0 = GetTime() local function Now() return GetTime() - T0 end -- client id: GetTime() = uptime of this WoW process, differs between clients local CLIENT_ID = format("%04d", math.mod(floor(GetTime() * 1000), 10000)) ------------------------------------------------------------------------ -- Output (buffer + file) ------------------------------------------------------------------------ local buf, nbuf = {}, 0 local fileName local writeMode -- "file", "sv" or nil (not decided yet) local bytesWritten, linesWritten, flushCount = 0, 0, 0 local lastFlushMs = 0 local SV_MAX_BYTES = 6 * 1024 * 1024 local function W(line) nbuf = nbuf + 1 buf[nbuf] = line end local function SVAppend(text) PerfLogDB = PerfLogDB or {} if PerfLogDB.session ~= fileName then PerfLogDB.session = fileName PerfLogDB.chunks = {} PerfLogDB.bytes = 0 end local chunks = PerfLogDB.chunks table.insert(chunks, text) PerfLogDB.bytes = (PerfLogDB.bytes or 0) + string.len(text) -- keep the beginning (header) and drop the oldest chunks after it while PerfLogDB.bytes > SV_MAX_BYTES and table.getn(chunks) > 2 do local removed = table.remove(chunks, 2) PerfLogDB.bytes = PerfLogDB.bytes - string.len(removed) end end local function Flush() if nbuf == 0 or not writeMode or not fileName then return end if not cfg.enabled then for i = 1, nbuf do buf[i] = nil end nbuf = 0 return end local text = tconcat(buf, "\n", 1, nbuf) .. "\n" local n = nbuf for i = 1, nbuf do buf[i] = nil end nbuf = 0 local t0 = clock() if writeMode == "file" then local ok, err = pcall(WriteCustomFile, fileName, text, "a") if not ok then Print("WriteCustomFile failed (" .. tostring(err) .. "), falling back to SavedVariables.") writeMode = "sv" SVAppend(text) end else SVAppend(text) end lastFlushMs = clock() - t0 bytesWritten = bytesWritten + string.len(text) linesWritten = linesWritten + n flushCount = flushCount + 1 W(format("F\t%.3f\t%.2f\t%d", Now(), lastFlushMs, string.len(text))) end ------------------------------------------------------------------------ -- Attributing frames to addons ------------------------------------------------------------------------ local WEAK = { __mode = "k" } local frameOwner = setmetatable({}, WEAK) -- frame -> addon local ownerSrc = setmetatable({}, WEAK) -- frame -> "stack" | "load" local OURS = setmetatable({}, WEAK) -- our own frames (not profiled) local addonNames -- addon folder names (fallback when Lua truncates the path with "...") -- PERF: debugstack() is slow (ClassicAPI's version): calling it for every -- CreateFrame while the addons load cost ~2.7 s per /reload (ducielperf -- watchdog). The calling file is now found with error(msg, level), which only -- formats "file:line:" of one stack level (CallerOwner). debugstack() is kept -- as a last resort after PLAYER_LOGIN only; before that, frames nobody claimed -- are tagged at each ADDON_LOADED by TagUntagged. local addonsLoading = true local error = error -- addon named by a debugstack() dump or an error position ("file:line: ") local function OwnerFromText(st) for a in string.gfind(st, "[Aa][Dd][Dd][Oo][Nn][Ss][\\/]([^\\/:\n]+)[\\/]") do if a ~= ADDON_NAME then return a end end -- long paths are truncated by Lua ("...odules\nameplates.lua"): look for -- a known addon folder name surrounded by path separators if sfind(st, "%.%.%.") and GetNumAddOns then if not addonNames then addonNames = {} for i = 1, GetNumAddOns() do local name = GetAddOnInfo(i) if name and name ~= ADDON_NAME then table.insert(addonNames, name) end end end for line in string.gfind(st, "[^\n]+") do if not sfind(line, ADDON_NAME, 1, true) then for i = 1, table.getn(addonNames) do local nm = addonNames[i] if sfind(line, "\\" .. nm .. "\\", 1, true) or sfind(line, "/" .. nm .. "/", 1, true) then return nm end end end end end if sfind(st, "FrameXML") then return "FrameXML" end return nil end -- Walk up the Lua stack one level at a time: error("", lvl) formats only that -- level's "file:line: " ("" for C functions and past the end of the stack). -- Raising an error is slow inside WoW (~1.1 s per /reload when the walk began at -- PerfLog's own levels), so CallerOwner must be called DIRECTLY by the hook: -- level 4 is then the code that called the hook (1 = pcall, 2 = CallerOwner, -- 3 = the hook). Usually one error per lookup, at most 4. local function CallerOwner(first) for lvl = first, first + 3 do local _, pos = pcall(error, "", lvl) if type(pos) == "string" and pos ~= "" and not sfind(pos, ADDON_NAME, 1, true) then local o = OwnerFromText(pos) if o then return o end end end return nil end -- last resort, after login only: the full stack dump (slow) local function StackOwner() if addonsLoading then return nil end if type(debugstack) ~= "function" then return nil end local ok, st = pcall(debugstack) if not ok or type(st) ~= "string" then return nil end return OwnerFromText(st) end local function SafeCall(obj, method) local f = obj and obj[method] if type(f) ~= "function" then return nil end local ok, r = pcall(f, obj) if ok then return r end return nil end local function OwnerOf(f) local o = frameOwner[f] if o then return o, ownerSrc[f] or "load" end local p = f for i = 1, 8 do p = SafeCall(p, "GetParent") if not p then break end o = frameOwner[p] if o then return o, "parent" end end return "?", "none" end local function FrameLabel(f) local n = SafeCall(f, "GetName") if n then return n end local t = SafeCall(f, "GetObjectType") or "Frame" local p = SafeCall(f, "GetParent") local pn = p and SafeCall(p, "GetName") if pn then return "<" .. t .. ">@" .. pn end return "<" .. t .. ">" end -- Tag every frame that has no owner yet as belonging to `owner` local function TagUntagged(owner) local n = 0 local f = EnumerateFrames() while f do if not frameOwner[f] then frameOwner[f] = owner ownerSrc[f] = "load" n = n + 1 end f = EnumerateFrames(f) end return n end ------------------------------------------------------------------------ -- Handler profiling ------------------------------------------------------------------------ local infos = {} -- id -> info local nextId = 0 local slots = setmetatable({}, WEAK) -- frame -> { script -> info } local wrapInfo = setmetatable({}, { __mode = "k" })-- wrapper -> info -- state shared by all wrappers local depth = 0 local ownAt = {} -- depth -> owner of the wrapped handler running there -- owner of the innermost profiled handler running now, if known (free) -- Hooks look for the owner of the code calling them with: -- HandlerOwner() or CallerOwner(4) or StackOwner() -- (CallerOwner called directly from the hook, see above) local function HandlerOwner() local o = depth > 0 and ownAt[depth] if o and o ~= "?" then return o end return nil end local childT, childM, evAt = {}, {}, {} local fLua = 0 -- Lua ms (handlers) since the last frame local frameNo = 0 local SPIKE_MAX = 64 local spikeN = 0 local spikeInfo, spikeKey, spikeMs = {}, {}, {} local evStamp, evFrameCount = {}, {} -- event -> frameNo / dispatches in that frame local evDispatch = {} -- event -> dispatches (window) local evFires = {} -- event -> occurrences (window, via RegisterAllEvents) local spikeThreshold = DEFAULTS.spikeMs local function MakeWrapper(info) local isEvent = (info.script == "OnEvent") local script = info.script local stats = info.stats return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) local orig = info.orig if not orig then return end if not PROF then return orig(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) end local key = script local d = depth + 1 if isEvent then key = event or a2 or "?" -- a chain of hooks (HookScript) counts as a single dispatch if d == 1 or evAt[d - 1] ~= key then evDispatch[key] = (evDispatch[key] or 0) + 1 if evStamp[key] ~= frameNo then evStamp[key] = frameNo evFrameCount[key] = 1 else evFrameCount[key] = evFrameCount[key] + 1 end end end evAt[d] = key ownAt[d] = info.owner -- frames created in this handler belong to its addon depth = d childT[d] = 0 childM[d] = 0 local m0 = gcinfo() local t0 = clock() orig(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) local dt = clock() - t0 local dm = gcinfo() - m0 depth = d - 1 if dt < 0 then dt = 0 end local gc = dm < 0 local ex = dt - (childT[d] or 0) if ex < 0 then ex = 0 end local exm = dm - (childM[d] or 0) if d > 1 then childT[d - 1] = (childT[d - 1] or 0) + dt if not gc then childM[d - 1] = (childM[d - 1] or 0) + dm end else fLua = fLua + dt end local s = stats[key] if not s then -- window: 1 calls, 2 ms, 3 max, 4 KB, 5 gc; cumulative: 6..10 s = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } stats[key] = s end s[1] = s[1] + 1 s[2] = s[2] + ex if ex > s[3] then s[3] = ex end if gc then s[5] = s[5] + 1 elseif exm > 0 then s[4] = s[4] + exm end if ex >= spikeThreshold and spikeN < SPIKE_MAX then spikeN = spikeN + 1 spikeInfo[spikeN] = info spikeKey[spikeN] = key spikeMs[spikeN] = ex end end end local function EmitInfo(info) W(format("R\t%d\t%s\t%s\t%s\t%s", info.id, San(info.owner), info.script, San(info.name), info.src)) end local function NewInfo(frame, script, owner, src) nextId = nextId + 1 local info = { id = nextId, script = script, owner = owner, src = src, name = FrameLabel(frame), stats = {}, frame = frame } info.wrapper = MakeWrapper(info) wrapInfo[info.wrapper] = info infos[nextId] = info local s = slots[frame] if not s then s = {}; slots[frame] = s end s[script] = info EmitInfo(info) return info end ------------------------------------------------------------------------ -- Hooking SetScript / GetScript (per widget type) ------------------------------------------------------------------------ local hookedMT = {} local origSet, origGet = {}, {} local validScripts = {} local hookedTypes = 0 local function MethodTable(f) local mt = getmetatable(f) if type(mt) ~= "table" then return nil end local idx = mt.__index if type(idx) == "table" then return idx end return nil end local function HookMethodTable(idx) if hookedMT[idx] then return end hookedMT[idx] = true local oSet, oGet = idx.SetScript, idx.GetScript if type(oSet) ~= "function" or type(oGet) ~= "function" then return end origSet[idx] = oSet origGet[idx] = oGet hookedTypes = hookedTypes + 1 idx.SetScript = function(self, sc, func) if not PROFILED[sc] or OURS[self] then return oSet(self, sc, func) end if type(func) ~= "function" or wrapInfo[func] then if func == nil then local s = slots[self] local info = s and s[sc] if info then info.orig = nil end end return oSet(self, sc, func) end local s = slots[self] local info = s and s[sc] if not info then local o, src = HandlerOwner() or CallerOwner(4) or StackOwner(), "stack" if not o then o, src = OwnerOf(self) end info = NewInfo(self, sc, o, src) elseif info.src ~= "stack" and not info.reowned then -- an addon replaces a handler set by XML: re-attribute it once -- (once the owner can be found: not while the addons load) local o = HandlerOwner() or CallerOwner(4) or StackOwner() if o then info.reowned = true info.src = "stack" if o ~= info.owner then info.owner = o EmitInfo(info) end end end info.orig = func return oSet(self, sc, info.wrapper) end idx.GetScript = function(self, sc) local f = oGet(self, sc) if f then local info = wrapInfo[f] if info then return info.orig end end return f end end local function HookAllExistingTypes() local f = EnumerateFrames() while f do local idx = MethodTable(f) if idx and not hookedMT[idx] then HookMethodTable(idx) end f = EnumerateFrames(f) end end local validByType = {} -- widget type -> { script -> supported } local function ValidScriptsFor(idx, f, oGet) local v = idx and validScripts[idx] if v then return v end -- PERF: without a method table (metatable __index is a function on some -- clients, e.g. hookedWidgetTypes 0) the cache above never hits, so every -- scan of every frame built a new table and called GetScript with up to 4 -- scripts the widget may not support, each failure building an error -- message: ~340 KB/s of garbage (ducielperf). Cache per widget type instead. local ot if not idx then local got = f.GetObjectType if type(got) == "function" then local ok, r = pcall(got, f) if ok and type(r) == "string" then ot = r end end v = ot and validByType[ot] if v then return v end end v = {} for i = 1, NSCRIPTS do local sc = SCRIPTS[i] v[sc] = pcall(oGet, f, sc) and true or false end if idx then validScripts[idx] = v elseif ot then validByType[ot] = v end return v end -- Wrap the scripts of a frame that do not go through us yet local function ScanFrame(f) if OURS[f] then return end local idx = MethodTable(f) if idx and not hookedMT[idx] then HookMethodTable(idx) end local oGet = (idx and origGet[idx]) or f.GetScript if type(oGet) ~= "function" then return end local valid = ValidScriptsFor(idx, f, oGet) for i = 1, NSCRIPTS do local sc = SCRIPTS[i] if valid[sc] then local cur = oGet(f, sc) -- SetScript is only looked up when a handler has to be wrapped local oSet = cur and not wrapInfo[cur] and ((idx and origSet[idx]) or f.SetScript) if type(oSet) == "function" then -- always a NEW info here: `cur` may be a chain (HookScript) that -- already calls our previous wrapper -> otherwise infinite recursion. local o, src local s = slots[f] local prev = s and s[sc] if prev then o, src = prev.owner, prev.src else o, src = OwnerOf(f) end local info = NewInfo(f, sc, o, src) info.orig = cur oSet(f, sc, info.wrapper) end end end end local scanCursor, scanRunning, scanNextAt = nil, false, 0 local scanCycleFrames, lastScanFrames = 0, 0 local function ScanStep(n) local f = scanCursor if not scanRunning then return end local t0 = clock() local budget = cfg.scanBudgetMs for i = 1, n do if clock() - t0 > budget then break end f = EnumerateFrames(f) if not f then scanRunning = false scanCursor = nil lastScanFrames = scanCycleFrames scanNextAt = GetTime() + cfg.rescan return end scanCycleFrames = scanCycleFrames + 1 ScanFrame(f) end scanCursor = f end local function StartScan() scanRunning = true scanCursor = nil scanCycleFrames = 0 end local function FullScanNow() local f = EnumerateFrames() local n = 0 while f do ScanFrame(f) n = n + 1 f = EnumerateFrames(f) end lastScanFrames = n return n end ------------------------------------------------------------------------ -- Per-addon allocation tracking (ducielperf DLL >= 0.3.0) -- DucielPerf_AllocTracking(1) switches it on (and resets the DLL counters), -- DucielPerf_AllocTracking() returns 1 when on. -- DucielPerf_GetAllocations(bytesT, countT) fills cumulative bytes / counts -- per bucket; the same tables are reused every time (no garbage). ------------------------------------------------------------------------ local AL = { avail = type(DucielPerf_AllocTracking) == "function" and type(DucielPerf_GetAllocations) == "function", on = false, -- PerfLog reads the counters started = "", -- "enabled" (PerfLog switched it on) / "already on" curB = {}, curN = {}, -- filled by DucielPerf_GetAllocations winB = {}, winN = {}, -- counters at the previous window dump (G lines) secB = {}, -- bytes at the previous tick (hitch attribution) reads = 0, lastMs = 0, maxMs = 0, errors = 0, buckets = 0, } local function AllocIsOn() local ok, v = pcall(DucielPerf_AllocTracking) return ok and (v == 1 or v == true) end local function AllocRead() local c0 = clock() local ok = pcall(DucielPerf_GetAllocations, AL.curB, AL.curN) local dt = clock() - c0 if not ok then AL.errors = AL.errors + 1 return false end AL.reads = AL.reads + 1 AL.lastMs = dt if dt > AL.maxMs then AL.maxMs = dt end return true end -- deltas are computed from the counter values at this moment local function AllocBaseline() local winB, winN, secB = AL.winB, AL.winN, AL.secB for k in pairs(winB) do winB[k] = nil end for k in pairs(winN) do winN[k] = nil end for k in pairs(secB) do secB[k] = nil end if AllocRead() then for name, b in pairs(AL.curB) do winB[name] = b secB[name] = b winN[name] = AL.curN[name] or 0 end end end -- on: make sure the DLL tracks (switch it on only if it is not on already, -- since switching on resets its counters). off: PerfLog stops reading it. local function AllocSet(on) AL.avail = type(DucielPerf_AllocTracking) == "function" and type(DucielPerf_GetAllocations) == "function" if not AL.avail then AL.on = false; return false end if on then if AllocIsOn() then AL.started = "already on" else pcall(DucielPerf_AllocTracking, 1) AL.started = "enabled" end AL.on = AllocIsOn() if AL.on then AllocBaseline() end else if AllocIsOn() then pcall(DucielPerf_AllocTracking, 0) end AL.on = false end return AL.on end -- G lines: allocations of each bucket since the previous window local function AllocDump(t, win) if not AL.on or not AllocRead() then return end local curB, curN, winB, winN = AL.curB, AL.curN, AL.winB, AL.winN local nb = 0 for name, b in pairs(curB) do nb = nb + 1 local n = curN[name] or 0 local db = b - (winB[name] or 0) local dn = n - (winN[name] or 0) if db < 0 or dn < 0 then db = b; dn = n end -- the DLL counters were reset if db > 0 then W(format("G\t%.3f\t%.1f\t%s\t%.1f\t%.0f", t, win, San(name), db / 1024, dn)) end winB[name] = b winN[name] = n end AL.buckets = nb end -- once per second: remember the counters (hitch attribution) local function AllocTick() if not AL.on or not AllocRead() then return end local secB = AL.secB for name, b in pairs(AL.curB) do secB[name] = b end end -- hitch frame: the 3 biggest allocators since the previous second, "name|KB;..." local function AllocTop() if not AL.on or not AllocRead() then return "-" end local secB = AL.secB local n1, n2, n3 local b1, b2, b3 = 0, 0, 0 for name, b in pairs(AL.curB) do local d = b - (secB[name] or 0) if d > b1 then n3, b3 = n2, b2; n2, b2 = n1, b1; n1, b1 = name, d elseif d > b2 then n3, b3 = n2, b2; n2, b2 = name, d elseif d > b3 then n3, b3 = name, d end end if not n1 then return "-" end local s = format("%s|%.1f", San(n1), b1 / 1024) if n2 then s = s .. format(";%s|%.1f", San(n2), b2 / 1024) end if n3 then s = s .. format(";%s|%.1f", San(n3), b3 / 1024) end return s end -- ducielperf is a WeirdUtils build: its version is in GetWeirdUtilsVersion() -- (DucielPerf_GetVersion is a C export of the DLL, not a Lua function) local function AllocVersion() if type(GetWeirdUtilsVersion) ~= "function" then return "absent" end local ok, t = pcall(GetWeirdUtilsVersion) if not ok or type(t) ~= "table" or not t.ducielperf then return "absent" end return tostring(t.ducielperf) .. (t.alloctrack and (" (alloctrack " .. tostring(t.alloctrack) .. ")") or "") end ------------------------------------------------------------------------ -- Engine frame counters and freeze watchdog (ducielperf DLL >= 0.4.0) -- DucielPerf_FrameStats([on]) -> 1 | nil (switching on resets the counters) -- DucielPerf_GetFrameStats([lastT [, worstT [, totalT]]]) -> frames -- keys: frameMs, Ms / Calls / Bytes, totalT.frames -- DucielPerf_Watchdog() -> on, thresholdMs, reportsWritten -- Times are inclusive and overlap (a read that decompresses counts in both). -- A DLL frame runs from the end of one rendered frame to the end of the next. ------------------------------------------------------------------------ -- "gc" (ducielperf >= 0.4.1): gcMs / gcCalls / gcBytes (= bytes freed); older DLLs give 0 local FS_NAMES = { "fileRead", "decompress", "fileFind", "modelOpen", "modelProcess", "textureLoad", "textureDone", "packet", "gc" } local FS_N = 9 local FS = { avail = false, on = false, started = "", keys = {}, -- 1..24: fileReadMs, fileReadCalls, fileReadBytes, decompressMs... last = {}, tot = {}, prev = {}, vals = {}, a = {}, pendT = nil, -- hitch waiting for its counters (see DpHitchEnd) pattern = "X\t%.3f\t%d\t%.1f" .. string.rep("\t%.2f\t%.0f\t%.0f", FS_N), wdAvail = false, wdOn = false, wdMs = 0, wdReports = nil, wdSeen = 0, } for i = 1, FS_N do local n = FS_NAMES[i] FS.keys[3 * i - 2] = n .. "Ms" FS.keys[3 * i - 1] = n .. "Calls" FS.keys[3 * i] = n .. "Bytes" end local function FsIsOn() local ok, v = pcall(DucielPerf_FrameStats) return ok and v ~= nil and v ~= false end -- fills the given tables (nil = skipped); true if the call worked, and the -- DLL's frame count (identifies the frame now in lastT) local function FsRead(lastT, totT) local ok, n = pcall(DucielPerf_GetFrameStats, lastT, nil, totT) return ok, n end -- on: read the counters, switching counting on only if it is off (the DLL's -- startup config normally has it on). off: PerfLog stops reading them; the -- DLL's counting is left as it is. local function FsSet(on) FS.avail = type(DucielPerf_FrameStats) == "function" and type(DucielPerf_GetFrameStats) == "function" if not FS.avail then FS.on = false; return false end if on then if FsIsOn() then FS.started = "already on" else pcall(DucielPerf_FrameStats, 1) FS.started = "enabled" end FS.on = FsIsOn() if FS.on and FsRead(nil, FS.tot) then local prev = FS.prev for k, v in pairs(FS.tot) do prev[k] = v end end else FS.on = false FS.pendT = nil end return FS.on end -- watchdog state; returns reportsWritten or nil local function WdRead() if type(DucielPerf_Watchdog) ~= "function" then FS.wdAvail = false; return nil end FS.wdAvail = true local ok, on, thr, n = pcall(DucielPerf_Watchdog) if not ok then return nil end FS.wdOn = on and true or false FS.wdMs = thr or 0 return n or 0 end -- once per tick, before the T line of the same t: -- X line = engine counters summed over the tick (deltas of totalT) -- M dp_freeze marker when the watchdog wrote new reports local function DpTick(t, maxMs) if FS.on and FsRead(nil, FS.tot) then local tot, prev, vals, keys = FS.tot, FS.prev, FS.vals, FS.keys local reset = (tot.frames or 0) < (prev.frames or 0) -- someone reset the DLL counters local frames = (tot.frames or 0) - (reset and 0 or (prev.frames or 0)) local fms = (tot.frameMs or 0) - (reset and 0 or (prev.frameMs or 0)) for i = 1, 3 * FS_N do local k = keys[i] local v = tot[k] or 0 vals[i] = reset and v or (v - (prev[k] or 0)) prev[k] = v end prev.frames = tot.frames prev.frameMs = tot.frameMs W(format(FS.pattern, t, frames, fms, unpack(vals))) end local n = WdRead() if n then if FS.wdReports and n > FS.wdReports then FS.wdSeen = FS.wdSeen + (n - FS.wdReports) W(format("M\t%.3f\tdp_freeze\t%d (+%d, worst frame this second %.0f ms)", t, n, n - FS.wdReports, maxMs)) end FS.wdReports = n end end -- Hitch: depending on where in the frame the time went, the slow DLL frame is -- either the last completed one now or the one that completes next. Keep the -- counters of now (DpHitchStart), compare with the next frame's (DpHitchEnd) -- and write the longer one as a Y line attached to the H line by its time. local function DpHitchStart(t, ms) if not FS.on then return end FS.pendMs = ms local ok, n = FsRead(FS.last, nil) if not ok then return end local a = FS.a for k, v in pairs(FS.last) do a[k] = v end FS.aFrame = n FS.pendT = t end -- Of the two candidate DLL frames, keep the one whose length is closest to the -- hitch's own duration. FS.usedFrame: DLL frame already given to the previous -- Y line, so that two hitches in a row don't both get the same frame. local function DpHitchEnd() local t = FS.pendT if not t then return end FS.pendT = nil local ms = FS.pendMs or 0 local src, srcN = nil, nil if FS.aFrame ~= FS.usedFrame then src, srcN = FS.a, FS.aFrame end local ok, n = FsRead(FS.last, nil) if ok and n ~= FS.usedFrame and n ~= FS.aFrame and (not src or math.abs((FS.last.frameMs or 0) - ms) < math.abs((src.frameMs or 0) - ms)) then src, srcN = FS.last, n end if not src then return end FS.usedFrame = srcN local keys = FS.keys local s = format("Y\t%.3f\t%.1f", t, src.frameMs or 0) for i = 1, FS_N do local ms = src[keys[3 * i - 2]] or 0 if ms >= 0.5 then s = s .. format("\t%s|%.1f|%.0f|%.0f", FS_NAMES[i], ms, src[keys[3 * i - 1]] or 0, (src[keys[3 * i]] or 0) / 1024) end end W(s) end ------------------------------------------------------------------------ -- Lua garbage collector statistics (ducielperf DLL >= 0.4.1, always on) -- DucielPerf_GetGCStats(t) fills cycles, totalMs, lastMs, maxMs, lastFreed, -- totalFreed, allocatedSinceLastCall, memory, threshold (bytes). -- allocatedSinceLastCall has one baseline: PerfLog is its only caller, once -- per OnUpdate, so each call covers exactly one PerfLog frame (arg1). ------------------------------------------------------------------------ local GCS = { avail = false, base = false, t = {}, cycles = 0, ms = 0, freed = 0 } local function GcRead() local ok = pcall(DucielPerf_GetGCStats, GCS.t) return ok end local function GcInit() GCS.avail = type(DucielPerf_GetGCStats) == "function" GCS.base = false if GCS.avail and GcRead() then local t = GCS.t GCS.cycles, GCS.ms, GCS.freed = t.cycles or 0, t.totalMs or 0, t.totalFreed or 0 GCS.base = true end end -- this frame: allocKB, collections, freedKB, gcMs (nil without the DLL) local function GcFrame() if not GCS.base or not GcRead() then return nil end local t = GCS.t local cyc, gms, fr = t.cycles or 0, t.totalMs or 0, t.totalFreed or 0 local dc, dms, dfr = cyc - GCS.cycles, gms - GCS.ms, fr - GCS.freed GCS.cycles, GCS.ms, GCS.freed = cyc, gms, fr if dc < 0 or dms < 0 or dfr < 0 then dc, dms, dfr = 0, 0, 0 end return (t.allocatedSinceLastCall or 0) / 1024, dc, dfr / 1024, dms end ------------------------------------------------------------------------ -- Garbage-free string building (ducielperf DLL >= 0.5.0, "strbuf") -- DucielPerf_GetStringBufferStats() -> results, largeResults, largeBytes, liveBuffers -- (exists only while the replacement is active). largeResults/largeBytes = -- strings over 512 bytes built by table.concat, string.rep/gsub/format...: -- the ones that used to create garbage, i.e. what the fix now saves. ------------------------------------------------------------------------ local SB = { r = 0, lr = 0, lb = 0, base = false } local function SbInit() SB.base = false if type(DucielPerf_GetStringBufferStats) ~= "function" then return end local ok, r, lr, lb = pcall(DucielPerf_GetStringBufferStats) if ok then SB.r, SB.lr, SB.lb, SB.base = r or 0, lr or 0, lb or 0, true end end -- B line once per window local function SbDump(t, win) if not SB.base then return end local ok, r, lr, lb, live = pcall(DucielPerf_GetStringBufferStats) if not ok then return end r, lr, lb = r or 0, lr or 0, lb or 0 local dr, dlr, dlb = r - SB.r, lr - SB.lr, lb - SB.lb if dr < 0 or dlr < 0 or dlb < 0 then dr, dlr, dlb = r, lr, lb end SB.r, SB.lr, SB.lb = r, lr, lb W(format("B\t%.3f\t%.1f\t%.0f\t%.0f\t%.1f\t%.0f", t, win, dr, dlr, dlb / 1024, live or 0)) end -- current BigWigs boss fight (see "Boss fights" below; declared here for the session header) local BOSS = { hooked = false, mod = nil, name = nil, start = 0 } -- ducielperf features PerfLog uses (one function: OnEvent is close to Lua 5.0's 32 upvalue limit) local function DllSetup() if cfg.alloc then AllocSet(true) end if cfg.frameStats then FsSet(true) end GcInit() SbInit() end ------------------------------------------------------------------------ -- Periodic dumps ------------------------------------------------------------------------ local lastWindowAt = 0 local function DumpProfile() local t = Now() local win = t - lastWindowAt lastWindowAt = t for id, info in pairs(infos) do for key, s in pairs(info.stats) do if s[1] > 0 then W(format("P\t%.3f\t%.1f\t%d\t%s\t%d\t%.3f\t%.3f\t%d\t%d", t, win, id, key, s[1], s[2], s[3], s[4], s[5])) s[6] = s[6] + s[1]; s[7] = s[7] + s[2] if s[3] > s[8] then s[8] = s[3] end s[9] = s[9] + s[4]; s[10] = s[10] + s[5] s[1] = 0; s[2] = 0; s[3] = 0; s[4] = 0; s[5] = 0 end end end for ev, n in pairs(evDispatch) do local fires = evFires[ev] or 0 if n > 0 or fires > 0 then W(format("E\t%.3f\t%.1f\t%s\t%d\t%d", t, win, ev, fires, n)) end evDispatch[ev] = 0 end for ev, n in pairs(evFires) do if n > 0 and not evDispatch[ev] then W(format("E\t%.3f\t%.1f\t%s\t%d\t%d", t, win, ev, n, 0)) end evFires[ev] = 0 end AllocDump(t, win) SbDump(t, win) end ------------------------------------------------------------------------ -- Session info ------------------------------------------------------------------------ local function S(k, v) W("S\t" .. k .. "\t" .. San(v)) end local CVARS = { "gxApi", "gxResolution", "gxRefresh", "gxColorBits", "gxDepthBits", "gxMultisample", "gxMultisampleQuality", "gxVSync", "gxTripleBuffer", "gxWindow", "gxMaximize", "gxCursor", "maxfps", "maxfpsbk", "farclip", "horizonfarclip", "farclipoverride", "groundEffectDensity", "groundEffectDist", "smallCull", "detailDoodadAlpha", "doodadAnim", "texLodBias", "spellEffectLevel", "weatherDensity", "unitDrawDist", "shadowLevel", "M2UsePixelShaders", "M2UseZFill", "M2UseClipPlanes", "M2UseThreads", "M2BatchDoodads", "M2Faster", "pixelShaders", "fullAlpha", "frillDensity", "lod", "SkyCloudLOD", "waterLOD", "mapShadows", "showfootprints", "particleDensity", "anisotropic", "trilinear", "textureCacheSize", "nameplateDistance", "UnitNameRenderMode", "showShadow", "NP_EnableUnitEventsGuid", "NP_EnableUnitEventsGuidFiltering", "NP_EnableUnitEventsRaid", "NP_EnableUnitEventsParty", "NP_EnableUnitEventsPet", "NP_EnableUnitEventsMouseover", "NP_NameplateDistance", "NP_EnableAuraCastEvents", "NP_EnableAutoAttackEvents", "NP_EnableSpellStartEvents", "NP_EnableSpellGoEvents", "NP_EnableSpellHealEvents", "NP_EnableSpellEnergizeEvents", "NP_EnableEnhancedTooltips", } local function WriteSessionInfo() S("addonVersion", VERSION) S("date", date("%Y-%m-%d %H:%M:%S")) S("gettime0", format("%.3f", T0)) local v, b, d = GetBuildInfo() S("build", tostring(v) .. " " .. tostring(b) .. " " .. tostring(d)) S("realm", GetRealmName and GetRealmName() or "?") S("char", UnitName and UnitName("player") or "?") S("clientId", CLIENT_ID) S("clock", CLOCK_NAME) S("clockResMs", format("%.4f", MeasureClockResolution())) S("writeMode", writeMode) S("debugstack", type(debugstack) == "function" and "yes" or "no") S("hookedWidgetTypes", hookedTypes) do local mt = getmetatable(UIParent) local idx = type(mt) == "table" and mt.__index S("frameMeta", type(mt) .. "/" .. type(idx) .. "/" .. type(type(idx) == "table" and rawget(idx, "SetScript"))) end S("superwow", SUPERWOW_VERSION or "absent") if type(GetNampowerVersion) == "function" then local ok, a, b2, c = pcall(GetNampowerVersion) S("nampower", ok and (tostring(a) .. "." .. tostring(b2) .. "." .. tostring(c)) or "?") else S("nampower", "absent") end S("classicapi", CLASSIC_API_VERSION or (C_AddOns and "present") or "absent") if type(GetWeirdUtilsVersion) == "function" then local ok, t = pcall(GetWeirdUtilsVersion) local parts = {} if ok and type(t) == "table" then for k2, v2 in pairs(t) do table.insert(parts, tostring(k2) .. "=" .. tostring(v2)) end end S("weirdutils", tconcat(parts, ",")) else S("weirdutils", "absent") end S("unitxp", type(UnitXP) == "function" and "present" or "absent") S("ducielperf", AllocVersion()) S("allocTracking", AL.on and ("on (" .. AL.started .. ")") or (AL.avail and "off" or "absent")) S("frameStats", FS.on and ("on (" .. FS.started .. ")") or (FS.avail and "off" or "absent")) S("gcStats", GCS.base and "exact (ducielperf)" or "gcinfo estimate") -- ducielperf >= 0.5.0 builds long strings without garbage: allocation and GC -- figures are not comparable with logs where this is "off/absent" S("strbuf", SB.base and "on (garbage-free string building)" or "off/absent") S("bossMarkers", BOSS.hooked and "BigWigs" or "off (BigWigs not found)") S("memSnapshots", (type(UpdateAddOnMemoryUsage) == "function" and type(GetAddOnMemoryUsage) == "function") and (cfg.memSnap and "each loading screen + /perflog mem" or "/perflog mem only") or "absent") do local n = WdRead() FS.wdReports = n S("watchdog", not FS.wdAvail and "absent" or (FS.wdOn and format("on %d ms, %d reports so far", FS.wdMs, n or 0) or "off")) end S("hitchMs", cfg.hitchMs) S("window", cfg.window) S("bgDetect", format("%d frames >= %d ms within %d%%", cfg.bgRun, cfg.bgMinMs, cfg.bgTol * 100)) S("profile", PROF and 1 or 0) -- addons local n = GetNumAddOns() for i = 1, n do local name, title, notes, enabled, loadable, reason = GetAddOnInfo(i) local loaded = IsAddOnLoaded(i) W(format("A\t%s\t%d\t%d", San(name), enabled and 1 or 0, loaded and 1 or 0)) end -- cvars for i = 1, table.getn(CVARS) do local ok, val = pcall(GetCVar, CVARS[i]) if ok and val ~= nil then W("C\t" .. CVARS[i] .. "\t" .. San(val)) end end end local function Mark(kind, text) W(format("M\t%.3f\t%s\t%s", Now(), kind, San(text or ""))) end ------------------------------------------------------------------------ -- Driver frame ------------------------------------------------------------------------ local driver = CreateFrame("Frame", "PerfLogDriverFrame") OURS[driver] = true local lastMem = gcinfo() -- counters of the current second (in a table: Lua 5.0 has a 32 upvalue limit) local tk = { acc = 0, frames = 0, max = 0, n33 = 0, n50 = 0, n100 = 0, alloc = 0, gc = 0, freed = 0, lua = 0, self = 0, bg = 0, gcMs = 0 } -- background (throttled window) detection -- on: in background; run/runMs/ref: current run of long regular frames; -- pend: hitch lines of the current run, written only if the run is not background local bgs = { on = false, run = 0, runMs = 0, ref = 0, pend = {}, npend = 0, since = 0, frames = 0, periods = 0, skipped = 0, total = 0 } -- general state local st = { nextFlushAt = 0, nextWindowAt = 0, loading = true, loadingUntil = 0, loadStart = GetTime(), inCombat = false, groupSize = 1, hitchCount = 0, childrenOK = WorldFrame and type(WorldFrame.GetNumChildren) == "function" } ------------------------------------------------------------------------ -- Boss fights (BigWigs) -- BigWigs calls BigWigsBossRecords:StartBossfight(module) when a boss is -- engaged and :EndBossfight(module) when it dies. A wipe or reset reboots -- the module, which sets module.engaged back to false: checked once per tick. -- M boss_start / M boss_kill (s) / M boss_wipe (s) -- The profile window (P/E/G/B lines) is closed at each of these markers, so -- windows line up with fights. ------------------------------------------------------------------------ local function BossWindowBreak(now) DumpProfile() st.nextWindowAt = now + cfg.window end local function BossEnd(kind) local now = GetTime() Mark(kind, format("%s (%.0fs)", BOSS.name or "?", now - BOSS.start)) BOSS.mod, BOSS.name = nil, nil BossWindowBreak(now) end local function BossStart(module) if not module or not module.bossSync or module.trashMod then return end if BOSS.mod then BossEnd("boss_wipe") end -- previous fight never ended local now = GetTime() BossWindowBreak(now) local name = module.translatedName if type(name) ~= "string" then name = tostring(module.bossSync) end BOSS.mod, BOSS.name, BOSS.start = module, name, now Mark("boss_start", name) end -- once per tick: a fight that stopped without a kill = wipe / reset local function BossTick() local m = BOSS.mod if m and not m.engaged then BossEnd("boss_wipe") end end local function HookBigWigs() local rec = BigWigsBossRecords if BOSS.hooked or type(rec) ~= "table" then return end local oStart, oEnd = rec.StartBossfight, rec.EndBossfight if type(oStart) ~= "function" or type(oEnd) ~= "function" then return end BOSS.hooked = true rec.StartBossfight = function(self, module) pcall(BossStart, module) return oStart(self, module) end rec.EndBossfight = function(self, module) if BOSS.mod and module == BOSS.mod then pcall(BossEnd, "boss_kill") end return oEnd(self, module) end end ------------------------------------------------------------------------ -- Lua memory per addon (ClassicAPI UpdateAddOnMemoryUsage / GetAddOnMemoryUsage) -- The recount walks all Lua memory (~30 ms with 55 MB), so it runs at each -- loading screen (hidden by it) and on /perflog mem, never on its own in combat. -- K t addon KB (one line per loaded addon, then M mem ...) ------------------------------------------------------------------------ local function MemSnapshot(reason) if type(UpdateAddOnMemoryUsage) ~= "function" or type(GetAddOnMemoryUsage) ~= "function" then return nil end local t0 = clock() if not pcall(UpdateAddOnMemoryUsage) then return nil end local dt = clock() - t0 local t, sum, n, top, topKB = Now(), 0, 0, nil, 0 for i = 1, GetNumAddOns() do if IsAddOnLoaded(i) then local name = GetAddOnInfo(i) local ok, kb = pcall(GetAddOnMemoryUsage, i) if ok and type(kb) == "number" then W(format("K\t%.3f\t%s\t%.1f", t, San(name), kb)) sum, n = sum + kb, n + 1 if kb > topKB then top, topKB = name, kb end end end end local total = gcinfo() Mark("mem", format("%s: %.1f MB in %d addons of %.1f MB Lua memory, biggest %s %.1f MB, recount %.0f ms", reason, sum / 1024, n, total / 1024, tostring(top), topKB / 1024, dt)) return sum, total, dt, top, topKB end local function SpikeString() if spikeN == 0 then return "-" end -- selection sort of the 5 biggest local out = {} local used = {} for k = 1, 5 do local best, bi = -1, nil for i = 1, spikeN do if not used[i] and spikeMs[i] > best then best = spikeMs[i]; bi = i end end if not bi then break end used[bi] = true table.insert(out, format("%d|%s|%.1f", spikeInfo[bi].id, spikeKey[bi], spikeMs[bi])) end return tconcat(out, ";") end local function EventString() local list = {} for ev, stamp in pairs(evStamp) do if stamp == frameNo then table.insert(list, ev) end end if table.getn(list) == 0 then return "-" end tsort(list, function(a, b) return evFrameCount[a] > evFrameCount[b] end) local out = {} for i = 1, math.min(6, table.getn(list)) do table.insert(out, list[i] .. "|" .. evFrameCount[list[i]]) end return tconcat(out, ";") end local function GroupSize() local r = GetNumRaidMembers and GetNumRaidMembers() or 0 if r > 0 then return r end local p = GetNumPartyMembers and GetNumPartyMembers() or 0 return p + 1 end local function EmitTick(now, mem, thr) local _, _, lat = GetNetStats() local children = 0 if st.childrenOK then children = WorldFrame:GetNumChildren() or 0 end W(format("T\t%.3f\t%.3f\t%d\t%.1f\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%.2f\t%.2f\t%d\t%d\t%d\t%d\t%.3f\t%.2f", now - T0, tk.acc, tk.frames, tk.max, tk.n33, tk.n50, tk.n100, lat or 0, mem, thr or 0, tk.alloc, tk.gc, tk.freed, tk.lua, tk.self, st.inCombat and 1 or 0, st.loading and 1 or 0, st.groupSize, children, tk.bg, tk.gcMs)) tk.acc, tk.frames, tk.max, tk.n33, tk.n50, tk.n100 = 0, 0, 0, 0, 0, 0 tk.alloc, tk.gc, tk.freed, tk.lua, tk.self, tk.bg, tk.gcMs = 0, 0, 0, 0, 0, 0, 0 end -- pending hitches of a run that turned out NOT to be background: write them local function BgFlushPending() for i = 1, bgs.npend do W(bgs.pend[i]) bgs.pend[i] = nil st.hitchCount = st.hitchCount + 1 end bgs.npend = 0 end -- pending hitches of a run that IS background: drop them local function BgDropPending() for i = 1, bgs.npend do bgs.pend[i] = nil end bgs.skipped = bgs.skipped + bgs.npend bgs.npend = 0 end -- Called once per frame before the hitch test; returns true while in background local function BgUpdate(ms, el, now) if bgs.on then if ms < cfg.bgMinMs then bgs.on = false bgs.run, bgs.runMs = 0, 0 Mark("bg_end", format("%.1fs, %d frames", now - bgs.since, bgs.frames)) return false end bgs.frames = bgs.frames + 1 tk.bg = tk.bg + el bgs.total = bgs.total + el return true end local long = ms >= cfg.bgMinMs and fLua < ms * 0.25 if long and bgs.run > 0 and math.abs(ms - bgs.ref) <= bgs.ref * cfg.bgTol then bgs.run = bgs.run + 1 bgs.runMs = bgs.runMs + ms else -- the previous run is over and was not background: its hitches were real BgFlushPending() if long then bgs.run, bgs.runMs = 1, ms else bgs.run, bgs.runMs = 0, 0 end end bgs.ref = ms if bgs.run >= cfg.bgRun then bgs.on = true bgs.periods = bgs.periods + 1 bgs.frames = bgs.run bgs.since = now - bgs.runMs / 1000 tk.bg = tk.bg + bgs.runMs / 1000 bgs.total = bgs.total + bgs.runMs / 1000 BgDropPending() Mark("bg_start", format("%.0f ms frames", ms)) return true end return false end local function Periodic(now) -- incremental scanner if scanRunning then ScanStep(cfg.scanBatch) elseif now >= scanNextAt and scanNextAt > 0 then StartScan() end if now >= st.nextWindowAt then st.nextWindowAt = now + cfg.window DumpProfile() end if now >= st.nextFlushAt or nbuf > 3000 then st.nextFlushAt = now + cfg.flush Flush() end end local function OnUpdate() local c0 = clock() local el = arg1 or 0 local ms = el * 1000 local now = GetTime() depth = 0 -- counters of the previous frame's hitch (Y line), now that the next DLL frame is complete DpHitchEnd() local mem, thr = gcinfo() local dmem, gcn, freed, gcMs = GcFrame() local gc if dmem then -- exact (ducielperf): bytes allocated, collections, bytes freed and GC time -- since the previous OnUpdate, i.e. over the same span as arg1 gc = gcn > 0 and 1 or 0 tk.gc = tk.gc + gcn tk.freed = tk.freed + freed tk.alloc = tk.alloc + dmem tk.gcMs = tk.gcMs + gcMs else -- estimate: a drop of gcinfo() = a collection dmem = mem - lastMem gc, freed = 0, 0 if dmem < 0 then gc = 1; freed = -dmem tk.gc = tk.gc + 1; tk.freed = tk.freed + freed else tk.alloc = tk.alloc + dmem end end if st.loading and st.loadingUntil > 0 and now >= st.loadingUntil then st.loading = false end -- window in background (throttled frame rate): not a slow frame local bg = BgUpdate(ms, el, now) -- slow frame? if not bg then if ms >= 33 then tk.n33 = tk.n33 + 1 end if ms >= 50 then tk.n50 = tk.n50 + 1 end if ms >= 100 then tk.n100 = tk.n100 + 1 end if ms > tk.max then tk.max = ms end if ms >= cfg.hitchMs and not st.loading then local line = format("H\t%.3f\t%.1f\t%.2f\t%d\t%d\t%d\t%s\t%s\t%d\t%s\t%s", now - T0, ms, fLua, (gc == 1 and not gcMs) and 0 or dmem, gc, freed, SpikeString(), EventString(), st.inCombat and 1 or 0, AllocTop(), gcMs and format("%.2f", gcMs) or "-") DpHitchStart(now - T0, ms) if bgs.run > 0 then -- part of a run of long regular frames: wait to know if it is background bgs.npend = bgs.npend + 1 bgs.pend[bgs.npend] = line else st.hitchCount = st.hitchCount + 1 W(line) end end end tk.lua = tk.lua + fLua fLua = 0 spikeN = 0 frameNo = frameNo + 1 tk.acc = tk.acc + el tk.frames = tk.frames + 1 if tk.acc >= cfg.tick then DpTick(now - T0, tk.max) -- before EmitTick, which resets tk.max EmitTick(now, mem, thr) AllocTick() BossTick() end Periodic(now) -- our own cost (includes disk writes) tk.self = tk.self + (clock() - c0) -- re-sync memory after our own work so that our allocations are not -- counted as allocations of the game lastMem = gcinfo() end ------------------------------------------------------------------------ -- Events ------------------------------------------------------------------------ local allEvents = pcall(driver.RegisterAllEvents, driver) local MY_EVENTS = { "ADDON_LOADED", "PLAYER_LOGIN", "PLAYER_LOGOUT", "PLAYER_ENTERING_WORLD", "PLAYER_LEAVING_WORLD", "PLAYER_REGEN_DISABLED", "PLAYER_REGEN_ENABLED", "ZONE_CHANGED_NEW_AREA", "RAID_ROSTER_UPDATE", "PARTY_MEMBERS_CHANGED", } if not allEvents then for i = 1, table.getn(MY_EVENTS) do driver:RegisterEvent(MY_EVENTS[i]) end end local loadTagged = {} -- File name unique per client: character + realm + date + process id -- (GetTime = uptime of each client, differs between two clients) local function FileSafe(s) s = gsub(tostring(s or ""), "[^%w%-]", "") if s == "" then s = "X" end return s end local function MakeFileName() local char = UnitName and UnitName("player") or "?" local realm = GetRealmName and GetRealmName() or "?" return "PerfLog_" .. FileSafe(char) .. "_" .. FileSafe(realm) .. "_" .. date("%Y%m%d_%H%M%S") .. "_" .. CLIENT_ID .. ".log" end -- handlers set during an addon's XML OnLoad (owner unknown until its ADDON_LOADED) local function ReassignUnknownOwners() for id, info in pairs(infos) do if info.owner == "?" and info.frame then local o, src = OwnerOf(info.frame) if o ~= "?" then info.owner = o info.src = src EmitInfo(info) end end end end local function OnLogin() addonsLoading = false -- every addon has had its ADDON_LOADED: call stacks are needed again st.groupSize = GroupSize() fileName = MakeFileName() WriteSessionInfo() local t0 = clock() local n = FullScanNow() S("initialScanFrames", n) S("initialScanMs", format("%.1f", clock() - t0)) S("handlersWrapped", nextId) scanNextAt = GetTime() + cfg.rescan Mark("login", "") Flush() if cfg.enabled then Print("logging to CustomData\\" .. tostring(fileName) .. (writeMode == "sv" and " (SavedVariables: WriteCustomFile not available)" or "") .. ". |cffaaaaaa/perflog for help|r") end end -- Load trace: CustomData\PerfLog_loadtrace.txt is rewritten at each load and each -- step is appended immediately (the main log only flushes every 10 s, so a freeze -- during loading leaves nothing in it). After a freeze, the last line shows the -- last step that completed; the culprit is whatever runs right after it. local function Trace(msg) if type(WriteCustomFile) ~= "function" then return end pcall(WriteCustomFile, "PerfLog_loadtrace.txt", format("%s\t%.3f\t%s\n", date("%H:%M:%S"), GetTime(), msg), "a") end local function OnEvent() local ev = event if ev == "ADDON_LOADED" then if arg1 == ADDON_NAME and type(WriteCustomFile) == "function" then pcall(WriteCustomFile, "PerfLog_loadtrace.txt", "# load started " .. date("%Y-%m-%d %H:%M:%S") .. "\n", "w") else Trace("addon_loaded " .. tostring(arg1)) end elseif ev == "PLAYER_LOGIN" or ev == "PLAYER_ENTERING_WORLD" then Trace(ev) elseif ev == "PLAYER_LOGOUT" then Trace("PLAYER_LOGOUT (PerfLog handler)") end if allEvents then evFires[ev] = (evFires[ev] or 0) + 1 end if ev == "ADDON_LOADED" then local name = arg1 if name == ADDON_NAME then if type(PerfLogConfig) ~= "table" then PerfLogConfig = {} end if PerfLogConfig.cfgVersion ~= 2 then -- v1.0: scanner too aggressive (caused hitches) -> new values PerfLogConfig.scanBatch = nil PerfLogConfig.rescan = nil PerfLogConfig.cfgVersion = 2 end for k, v in pairs(DEFAULTS) do if PerfLogConfig[k] == nil then PerfLogConfig[k] = v end cfg[k] = PerfLogConfig[k] end PROF = cfg.profile and true or false spikeThreshold = cfg.spikeMs -- before the other addons load, so their loading allocations are counted DllSetup() if type(WriteCustomFile) == "function" then writeMode = "file" else writeMode = "sv" PerfLogDB = {} end else if name == "BigWigs" then HookBigWigs() end local n = TagUntagged(name) loadTagged[name] = n ReassignUnknownOwners() W(format("M\t%.3f\taddon_loaded\t%s (%d frames)", Now(), San(name), n)) end elseif ev == "PLAYER_LOGIN" then OnLogin() elseif ev == "PLAYER_ENTERING_WORLD" then local dur = GetTime() - st.loadStart Mark("loading_end", format("%.1fs%s", dur, arg2 and " (reload)" or "")) st.loading = true st.loadingUntil = GetTime() + 3 st.inCombat = UnitAffectingCombat and UnitAffectingCombat("player") and true or false Mark("zone", GetRealZoneText and GetRealZoneText() or "?") -- memory per addon: the recount is hidden by the loading screen if cfg.memSnap and not st.inCombat then MemSnapshot("zone " .. (GetRealZoneText and GetRealZoneText() or "?")) end elseif ev == "PLAYER_LEAVING_WORLD" then st.loading = true st.loadingUntil = 0 st.loadStart = GetTime() Mark("loading_start", "") Flush() elseif ev == "PLAYER_REGEN_DISABLED" then st.inCombat = true Mark("combat_start", UnitName and UnitName("target") or "") elseif ev == "PLAYER_REGEN_ENABLED" then st.inCombat = false Mark("combat_end", "") elseif ev == "ZONE_CHANGED_NEW_AREA" then Mark("zone", GetRealZoneText and GetRealZoneText() or "?") elseif ev == "RAID_ROSTER_UPDATE" or ev == "PARTY_MEMBERS_CHANGED" then local g = GroupSize() if g ~= st.groupSize then st.groupSize = g Mark("group", tostring(g)) end elseif ev == "PLAYER_LOGOUT" then BgFlushPending() Mark("logout", "") DumpProfile() Flush() end end driver:SetScript("OnEvent", OnEvent) driver:SetScript("OnUpdate", OnUpdate) ------------------------------------------------------------------------ -- Installing hooks (when this file loads, before other addons) ------------------------------------------------------------------------ do local n = TagUntagged("FrameXML") W(format("M\t%.3f\taddon_loaded\tFrameXML (%d frames)", Now(), n)) HookAllExistingTypes() -- make sure common widget types are hooked even without an existing instance local probe = { "Frame", "Button", "CheckButton", "StatusBar", "Slider", "ScrollFrame", "Model" } for i = 1, table.getn(probe) do local ok, f = pcall(CreateFrame, probe[i]) if ok and f then OURS[f] = true local idx = MethodTable(f) if idx then HookMethodTable(idx) end if f.Hide then f:Hide() end end end -- attribute frames created through CreateFrame local oCreateFrame = CreateFrame CreateFrame = function(ftype, name, parent, inherits) local f = oCreateFrame(ftype, name, parent, inherits) if f and not frameOwner[f] then -- CallerOwner(4) = the code that called CreateFrame; nil = left to TagUntagged local o = HandlerOwner() or CallerOwner(4) or StackOwner() if o then frameOwner[f] = o ownerSrc[f] = "stack" end local idx = MethodTable(f) if idx and not hookedMT[idx] then HookMethodTable(idx) end end return f end end ------------------------------------------------------------------------ -- Commands ------------------------------------------------------------------------ local function TopReport(nOwners, nHandlers) local byOwner, ownerMem, rows = {}, {}, {} local total = 0 for id, info in pairs(infos) do for key, s in pairs(info.stats) do local ms = s[2] + s[7] local kb = s[4] + s[9] if ms > 0 or kb > 0 then byOwner[info.owner] = (byOwner[info.owner] or 0) + ms ownerMem[info.owner] = (ownerMem[info.owner] or 0) + kb total = total + ms table.insert(rows, { ms = ms, kb = kb, n = s[1] + s[6], label = info.owner .. " " .. info.name .. ":" .. key }) end end end local owners = {} for o, ms in pairs(byOwner) do table.insert(owners, { o = o, ms = ms, kb = ownerMem[o] }) end tsort(owners, function(a, b) return a.ms > b.ms end) tsort(rows, function(a, b) return a.ms > b.ms end) local up = Now() Print(format("Top addons (cumulative Lua CPU over %.0fs, total %.0f ms = %.1f%%):", up, total, up > 0 and total / (up * 10) or 0)) for i = 1, math.min(nOwners, table.getn(owners)) do local o = owners[i] Print(format(" %d. %s: %.0f ms (%.2f ms/s), %.0f KB allocated", i, o.o, o.ms, o.ms / math.max(up, 1), o.kb or 0)) end Print("Top handlers:") for i = 1, math.min(nHandlers, table.getn(rows)) do local r = rows[i] Print(format(" %d. %s: %.0f ms / %d calls, %.0f KB", i, r.label, r.ms, r.n, r.kb)) end end local function SaveCfg() if type(PerfLogConfig) == "table" then for k in pairs(DEFAULTS) do PerfLogConfig[k] = cfg[k] end end end SLASH_PERFLOG1 = "/perflog" SLASH_PERFLOG2 = "/plog" SlashCmdList["PERFLOG"] = function(msg) msg = msg or "" local _, _, cmd, rest = sfind(msg, "^%s*(%S*)%s*(.-)%s*$") cmd = string.lower(cmd or "") if cmd == "mark" or cmd == "m" then Mark("user", rest) Print("marker added: " .. rest) elseif cmd == "top" then TopReport(10, 10) elseif cmd == "flush" then DumpProfile() Flush() Print("log written.") elseif cmd == "on" or cmd == "off" then cfg.enabled = (cmd == "on") SaveCfg() Mark("logging", cmd) Print("logging: " .. cmd) elseif cmd == "profile" then if rest == "on" then PROF = true elseif rest == "off" then PROF = false else PROF = not PROF end cfg.profile = PROF SaveCfg() Mark("profile", PROF and "on" or "off") Print("handler profiling: " .. (PROF and "on" or "off")) elseif cmd == "alloc" then local want if rest == "on" then want = true elseif rest == "off" then want = false else want = not AL.on end AllocSet(want) if not AL.avail then Print("allocation tracking needs ducielperf 0.3.0+ (DucielPerf_AllocTracking not found).") else cfg.alloc = want SaveCfg() Mark("alloc", AL.on and ("on (" .. AL.started .. ")") or "off") Print("per-addon allocation tracking: " .. (AL.on and ("on (" .. AL.started .. ")") or "off")) end elseif cmd == "fs" or cmd == "framestats" then local want if rest == "on" then want = true elseif rest == "off" then want = false else want = not FS.on end FsSet(want) if not FS.avail then Print("engine frame counters need ducielperf 0.4.0+ (DucielPerf_FrameStats not found).") else cfg.frameStats = want SaveCfg() Mark("frameStats", FS.on and ("on (" .. FS.started .. ")") or "off") Print("engine frame counters: " .. (FS.on and ("on (" .. FS.started .. ")") or "off (PerfLog stops reading them; the DLL keeps counting)")) end elseif cmd == "mem" then if st.inCombat and rest ~= "force" then Print("in combat: the recount takes ~30 ms or more. /perflog mem force to do it anyway.") else local sum, total, dt = MemSnapshot("/perflog mem") if not sum then Print("Lua memory per addon needs ClassicAPI (UpdateAddOnMemoryUsage not found).") else local list = {} for i = 1, GetNumAddOns() do if IsAddOnLoaded(i) then local name = GetAddOnInfo(i) local ok, kb = pcall(GetAddOnMemoryUsage, i) if ok and type(kb) == "number" then table.insert(list, { name = name, kb = kb }) end end end tsort(list, function(a, b) return a.kb > b.kb end) Print(format("Lua memory: %.1f MB in addons of %.1f MB in total (recount %.0f ms). Biggest:", sum / 1024, total / 1024, dt)) for i = 1, math.min(10, table.getn(list)) do Print(format(" %d. %s: %.1f MB", i, list[i].name, list[i].kb / 1024)) end end end elseif cmd == "hitch" and tonumber(rest) then cfg.hitchMs = tonumber(rest); SaveCfg() Print("hitch threshold: " .. cfg.hitchMs .. " ms") elseif cmd == "window" and tonumber(rest) then cfg.window = math.max(5, tonumber(rest)); SaveCfg() Print("profile window: " .. cfg.window .. " s") elseif cmd == "gc" then local before = gcinfo() local t0 = clock() collectgarbage() local dt = clock() - t0 local after = gcinfo() Mark("user_gc", format("%d->%d KB in %.1f ms", before, after, dt)) Print(format("forced GC: %d KB -> %d KB in %.1f ms", before, after, dt)) elseif cmd == "status" or cmd == "" then local mem, thr = gcinfo() Print(format("v%s file: %s (%s)", VERSION, tostring(fileName), tostring(writeMode))) Print(format(" log %s, profiling %s, %d handlers profiled, %d widget types hooked, clock %s", cfg.enabled and "on" or "off", PROF and "on" or "off", nextId, hookedTypes, CLOCK_NAME)) Print(format(" %d lines / %.0f KB written, %d hitches, Lua memory %.1f MB (GC at %.1f MB)", linesWritten, bytesWritten / 1024, st.hitchCount, mem / 1024, (thr or 0) / 1024)) Print(format(" window in background: %d time(s), %.0fs in total, %d throttled frames not counted as hitches%s", bgs.periods, bgs.total, bgs.skipped, bgs.on and " (in background now)" or "")) if AL.on then Print(format(" allocation tracking on (%s): %d buckets, %d reads, last %.3f ms, max %.3f ms, %d errors", AL.started, AL.buckets, AL.reads, AL.lastMs, AL.maxMs, AL.errors)) else Print(" allocation tracking " .. (AL.avail and "off" or "unavailable (ducielperf 0.3.0+ not found)")) end if GCS.base then local g = GCS.t Print(format(" GC (exact, ducielperf): %d collections, %.0f ms in total, longest %.1f ms, last %.1f ms (%.0f KB freed), threshold %.1f MB", g.cycles or 0, g.totalMs or 0, g.maxMs or 0, g.lastMs or 0, (g.lastFreed or 0) / 1024, (g.threshold or 0) / 1048576)) end Print(" engine frame counters " .. (FS.on and ("on (" .. FS.started .. ")") or (FS.avail and "off" or "unavailable")) .. ", freeze watchdog " .. (not FS.wdAvail and "unavailable" or (FS.wdOn and format("on (%d ms), %d reports this session", FS.wdMs, FS.wdSeen) or "off"))) Print("|cffaaaaaaCommands: /perflog mark | top | flush | on | off | profile [on|off] | alloc [on|off] | fs [on|off] | mem | hitch | window | gc|r") else Print("unknown command. /perflog for help.") end end