438 lines
10 KiB
JavaScript
438 lines
10 KiB
JavaScript
/*
|
|
TYPES OF PROFILING
|
|
|
|
cpu frames - gets stack frames randomly for a few seconds
|
|
report - can see specific events that happened. Includes inclusive vs noninclusive times.
|
|
snapshot - See the amount of something every amount of time
|
|
memory - can see how much memory is allocated and from where
|
|
*/
|
|
|
|
var t_units = ["ns", "us", "ms", "s", "ks", "Ms"];
|
|
|
|
function calc_cpu(fn, times, diff = 0) {
|
|
var series = [];
|
|
|
|
for (var i = 0; i < times; i++) {
|
|
var st = profile.now();
|
|
fn(i);
|
|
series.push(profile.now() - st - diff);
|
|
}
|
|
|
|
return series;
|
|
}
|
|
|
|
function empty_fn() {}
|
|
|
|
profile.cpu = function profile_cpu(fn, times = 1, q = "unnamed") {
|
|
var retgather = gathering_cpu;
|
|
profile.gather_stop();
|
|
var empty = calc_cpu(empty_fn, 100000);
|
|
var mean = Math.mean(empty);
|
|
var series = calc_cpu(fn, times, mean);
|
|
|
|
var elapsed = Math.sum(series);
|
|
var avgt = profile.best_t(elapsed / series.length);
|
|
var totalt = profile.best_t(elapsed);
|
|
|
|
say(`profile [${q}]: ${avgt} ± ${profile.best_t(Math.ci(series))} [${totalt} for ${times} loops]`);
|
|
say(`result of function is ${fn()}`);
|
|
|
|
if (retgather) profile.start_prof_gather();
|
|
};
|
|
|
|
profile.ms = function (t) {
|
|
return profile.secs(t) * 1000;
|
|
};
|
|
|
|
var callgraph = {};
|
|
profile.rawstacks = {};
|
|
|
|
function add_callgraph_from_stack(err, time)
|
|
{
|
|
var stack = err.stack.split("\n").slice(1);
|
|
var rawstack = stack.join("\n");
|
|
profile.rawstacks[rawstack] ??= {
|
|
time: 0,
|
|
hits: 0,
|
|
};
|
|
profile.rawstacks[rawstack].hits++;
|
|
profile.rawstacks[rawstack].time += time;
|
|
|
|
stack = stack.map(x => x.slice(7).split(" "));
|
|
|
|
var fns = stack.map(x => x[0]).filter(x => x);
|
|
var lines = stack.map(x => x[1]).filter(x => x);
|
|
lines = lines.map(x => x.slice(1, x.length - 1));
|
|
|
|
add_callgraph(fns[0], lines[0], time, true);
|
|
for (var i = 1; i < fns.length; i++) add_callgraph(fns[i], lines[i], time, false);
|
|
}
|
|
|
|
function add_callgraph(fn, line, time, alone) {
|
|
var cc = callgraph[line];
|
|
if (!cc) {
|
|
var cc = {};
|
|
callgraph[line] = cc;
|
|
cc.time = 0;
|
|
cc.hits = 0;
|
|
cc.fn = fn;
|
|
cc.line = line;
|
|
cc.alone = {
|
|
time: 0,
|
|
hits: 0,
|
|
};
|
|
}
|
|
cc.time += time;
|
|
cc.hits++;
|
|
|
|
if (alone) {
|
|
cc.alone.time += time;
|
|
cc.alone.hits++;
|
|
}
|
|
}
|
|
|
|
var hittar = 500; // number of call instructions before getting a new frame
|
|
var hitpct = 0.2; // amount to randomize it
|
|
var start_gather = profile.now();
|
|
|
|
profile.cpu_start = undefined;
|
|
|
|
profile.clear_cpu = function () {
|
|
callgraph = {};
|
|
profile.cpu_instr = undefined;
|
|
profile.gather_stop();
|
|
profile.cpu_start = undefined;
|
|
};
|
|
|
|
function cpu_record_frame()
|
|
{
|
|
|
|
}
|
|
|
|
// These values are set to get the most amount of frames without causing a stack overflow
|
|
var hittar = 450;
|
|
var hitpct = 0.2;
|
|
|
|
profile.start_cpu_gather_fn = function()
|
|
{
|
|
if (profile.cpu_start) return;
|
|
profile.clear_cpu();
|
|
|
|
profile.cpu_start = profile.now();
|
|
var st = profile.cpu_start;
|
|
|
|
profile.gather(Math.variate(hittar,hitpct), function() {
|
|
var time = profile.now() - st;
|
|
var err = new Error();
|
|
add_callgraph_from_stack(err, time);
|
|
st = profile.now();
|
|
profile.gather_rate(Math.variate(hittar,hitpct));
|
|
});
|
|
}
|
|
|
|
profile.start_cpu_gather = function (gathertime = 5) {
|
|
if (profile.cpu_start) return;
|
|
profile.clear_cpu();
|
|
|
|
// gather cpu frames for 'gathertime' seconds
|
|
profile.cpu_start = profile.now();
|
|
var st = profile.cpu_start;
|
|
|
|
profile.gather(hittar, function () {
|
|
var time = profile.now() - st;
|
|
|
|
var err = new Error();
|
|
add_callgraph_from_stack(err, time);
|
|
st = profile.now();
|
|
|
|
if (profile.secs(st - profile.cpu_start) < gathertime)
|
|
profile.gather_rate(Math.variate(hittar, hitpct));
|
|
else
|
|
profile.stop_cpu_measure();
|
|
});
|
|
};
|
|
|
|
profile.stop_cpu_measure = function()
|
|
{
|
|
if (!profile.cpu_start) return;
|
|
profile.gather_stop();
|
|
var gathertime = profile.now()-profile.cpu_start;
|
|
console.info(`gathered for ${profile.best_t(gathertime)}`);
|
|
profile.cpu_start = undefined;
|
|
var e = Object.values(callgraph);
|
|
e = e.filter(x => x.line);
|
|
|
|
for (var x of e) {
|
|
var ffs = x.line.split(":");
|
|
|
|
x.timestr = profile.best_t(x.time);
|
|
x.timeper = x.time / x.hits;
|
|
x.timeperstr = profile.best_t(x.timeper);
|
|
x.pct = x.time/gathertime * 100;
|
|
x.alone.timestr = profile.best_t(x.alone.time);
|
|
x.alone.timeper = x.alone.time / x.alone.hits;
|
|
x.alone.timeperstr = profile.best_t(x.alone.timeper);
|
|
x.alone.pct = x.alone.time / gathertime * 100;
|
|
x.fncall = get_line(ffs[0], ffs[1]);
|
|
x.log = x.line + " " + x.fn + " " + x.fncall;
|
|
x.incl = {
|
|
time: x.time,
|
|
timestr: x.timestr,
|
|
timeper: x.timeper,
|
|
timeperstr: x.timeperstr,
|
|
hits: x.hits,
|
|
pct: x.pct,
|
|
};
|
|
}
|
|
profile.cpu_instr = e;
|
|
}
|
|
|
|
function push_time(arr, ob, max) {
|
|
arr.push({
|
|
time: profile.now(),
|
|
ob,
|
|
});
|
|
}
|
|
|
|
profile.cpu_frames = [];
|
|
profile.last_cpu_frame = undefined;
|
|
profile.cpu_frame = function () {
|
|
profile.gather(Math.random_range(300, 600), function () {
|
|
var err = new Error();
|
|
profile.last_cpu_frame = err.stack; //.split('\n').slicconsole.stack(2);
|
|
profile.gather_stop();
|
|
});
|
|
};
|
|
|
|
var filecache = {};
|
|
function get_line(file, line) {
|
|
var text = filecache[file];
|
|
if (!text) {
|
|
var f = io.slurp(file);
|
|
if (!f) {
|
|
filecache[file] = "undefined";
|
|
return filecache[file];
|
|
}
|
|
filecache[file] = io.slurp(file).split("\n");
|
|
text = filecache[file];
|
|
}
|
|
|
|
if (typeof text === "string") return text;
|
|
text = text[Number(line) - 1];
|
|
if (!text) return "NULL";
|
|
return text.trim();
|
|
}
|
|
|
|
profile.stop_cpu_instr = function () {
|
|
return;
|
|
};
|
|
|
|
profile.best_t = function (t) {
|
|
var qq = 0;
|
|
|
|
while (t > 1000 && qq < t_units.length - 1) {
|
|
t /= 1000;
|
|
qq++;
|
|
}
|
|
|
|
return `${t.toPrecision(4)} ${t_units[qq]}`;
|
|
};
|
|
|
|
/*
|
|
Frame averages are an instrumented profiling technique. Place frame() calls
|
|
in your code to get a call graph for things you are interested in.
|
|
*/
|
|
|
|
var frame_avg = false;
|
|
|
|
profile.start_frame_avg = function () {
|
|
if (frame_avg) return;
|
|
profile_frames = {};
|
|
profile_frame_ts = [];
|
|
profile_cframe = profile_frames;
|
|
pframe = 0;
|
|
frame_avg = true;
|
|
};
|
|
|
|
profile.stop_frame_avg = function () {
|
|
frame_avg = false;
|
|
};
|
|
|
|
profile.toggle_frame_avg = function () {
|
|
if (frame_avg) profile.stop_frame_avg();
|
|
else profile.start_frame_avg();
|
|
};
|
|
|
|
var profile_framer = {
|
|
series: [],
|
|
avg: {},
|
|
frame: 72000,
|
|
};
|
|
var profile_cframe = undefined;
|
|
var pframe = 0;
|
|
var profile_stack = [];
|
|
|
|
profile.frame = function profile_frame(title) {
|
|
return;
|
|
if (profile.cpu_start) return;
|
|
if (!frame_avg) return;
|
|
|
|
if (!profile_cframe) {
|
|
profile_cframe = {};
|
|
profile_framer.series.push({
|
|
time: profile.now(),
|
|
data: profile_cframe,
|
|
});
|
|
} else profile_stack.push(profile_cframe);
|
|
|
|
profile_cframe[title] ??= {};
|
|
profile_cframe = profile_cframe[title];
|
|
profile_cframe.time = profile.now();
|
|
};
|
|
|
|
profile.endframe = function profile_endframe() {
|
|
return;
|
|
if (!frame_avg) return;
|
|
profile_cframe.time = profile.now() - profile_cframe.time;
|
|
profile_cframe = profile_frame_ts.pop();
|
|
};
|
|
|
|
profile.data = {};
|
|
profile.curframe = 0;
|
|
profile.snapshot = {};
|
|
|
|
var classes = ["gameobject", "transform", "dsp_node", "texture", "font", "warp_gravity", "warp_damp", "sg_buffer", "datastream", "cpShape", "cpConstraint", "timer", "skin"];
|
|
var get_snapshot = function()
|
|
{
|
|
var snap = profile.snapshot;
|
|
|
|
for (var monitor of monitors) {
|
|
var stat = monitor.fn();
|
|
monitor.hook?.(stat);
|
|
snap[monitor.path] = stat;
|
|
}
|
|
|
|
snap.actors = actor.__stats();
|
|
snap.memory.textures = game.texture.total_size();
|
|
snap.memory.texture_vram = game.texture.total_vram();
|
|
|
|
snap.particles = stat_emitters();
|
|
|
|
snap.obj ??= {};
|
|
for (var i of classes) {
|
|
var proto = globalThis[`${i}_proto`];
|
|
if (!proto) continue;
|
|
snap.obj[i] = proto._count();
|
|
snap.obj[i + "_mem"] = proto._count() * proto.memsize();
|
|
}
|
|
}
|
|
|
|
var monitors = [];
|
|
|
|
profile.add_custom_monitor = function(path, fn, hook)
|
|
{
|
|
monitors.push({
|
|
path:path,
|
|
fn:fn,
|
|
hook:hook
|
|
});
|
|
}
|
|
|
|
profile.add_custom_monitor('rusage', os.rusage, stat => stat.ru_maxrss *= 1024);
|
|
profile.add_custom_monitor('mallinfo', os.mallinfo);
|
|
profile.add_custom_monitor('memory', os.mem);
|
|
|
|
var fps = [];
|
|
var frame_lead = 1;
|
|
var fps_t = 0;
|
|
profile.report_frame = function (t) {
|
|
fps.push(t);
|
|
if (profile.secs(profile.now() - fps_t) > frame_lead) {
|
|
profile.snapshot.fps = Math.mean(fps);
|
|
fps.length = 0;
|
|
fps_t = profile.now();
|
|
get_snapshot();
|
|
}
|
|
}
|
|
|
|
profile.reports = {};
|
|
|
|
profile.report = function(path)
|
|
{
|
|
profile.reports[path] ??= {
|
|
report: path,
|
|
time: 0,
|
|
hits: 0,
|
|
avg: 0
|
|
};
|
|
if (profile.reports[path].st) return;
|
|
profile.reports[path].st = profile.now();
|
|
}
|
|
|
|
profile.endreport = function(path)
|
|
{
|
|
var rep = profile.reports[path];
|
|
if (!rep || !rep.st) return;
|
|
rep.hits++;
|
|
rep.time += profile.now()-rep.st;
|
|
delete rep.st;
|
|
rep.avg = rep.time/rep.hits;
|
|
|
|
profile.report_cache = Object.values(profile.reports);
|
|
}
|
|
|
|
function prof_add_stats(obj, stat) {
|
|
for (var i in stat) {
|
|
obj[i] ??= [];
|
|
if (obj[i].last() !== stat[i]) obj[i][profile.curframe] = stat[i];
|
|
}
|
|
}
|
|
|
|
profile.pushdata = function (arr, val) {
|
|
if (arr.last() !== val) arr[profile.curframe] = val;
|
|
};
|
|
|
|
profile.capturing = false;
|
|
profile.capture_data = function () {
|
|
if (!profile.capturing && profile.data.memory.malloc_size) return;
|
|
prof_add_stats(profile.data.memory, os.mem());
|
|
prof_add_stats(profile.data.gfx, imgui.framestats());
|
|
prof_add_stats(profile.data.actors, actor.__stats());
|
|
profile.curframe++;
|
|
};
|
|
|
|
profile.best_mem = function (bytes) {
|
|
var sizes = ["Bytes", "KB", "MB", "GB", "TB"];
|
|
if (bytes == 0) return "0 Bytes";
|
|
var i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
|
|
return (bytes / Math.pow(1024, i)).toPrecision(3) + " " + sizes[i];
|
|
};
|
|
|
|
profile.cleardata = function () {
|
|
profile.data.gpu = {};
|
|
profile.data.physics = {};
|
|
profile.data.script = {};
|
|
profile.data.memory = {};
|
|
profile.data.gfx = {};
|
|
profile.data.actors = {};
|
|
profile.data.cpu = {
|
|
scripts: [],
|
|
render: [],
|
|
physics: [],
|
|
};
|
|
};
|
|
|
|
profile.cleardata();
|
|
|
|
profile.last_mem = undefined;
|
|
profile.mems = [];
|
|
profile.gcs = [];
|
|
profile.print_gc = function () {
|
|
var gc = os.check_gc();
|
|
if (!gc) return;
|
|
profile.data.gc ??= [];
|
|
profile.data.gc[profile.curframe] = gc;
|
|
};
|
|
|
|
return { profile };
|