socket-function 1.1.48 → 1.2.0

package/src/profiling/dist/getOwnTime.ts.cache

@@ -0,0 +1,100 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getOwnTime = exports.measureOverheadTime = exports.getOpenTimesBase = void 0;
+const createSingleton_1 = require("../createSingleton");
+// TODO: We could probably make this an optional / dev dependency, to allow
+//  for use on machines without the ability to compile?
+//import { now } from "rdtsc-now";
+let now = () => performance.now();
+// Shared across every copy of this package loaded in the process, so a profile started via one
+//  copy's startMeasure nests correctly with getOwnTime calls made through another copy. The
+//  open-time stack MUST be a single instance, otherwise cross-copy nesting/own-time accounting
+//  breaks (a function wrapped by copy A calling one wrapped by copy B would push onto a different
+//  stack). See createSingleton.
+const openTimes = (0, createSingleton_1.createSingleton)("measure.openTimes", 1, () => []).get();
+function getOpenTimesBase() {
+    return openTimes;
+}
+exports.getOpenTimesBase = getOpenTimesBase;
+globalThis.pendingOwnCallTime = openTimes;
+// NOTE: This overhead time is actually mostly for aggregate time, but it is needed,
+//  otherwise we consistently underestimate the time spent.
+//  ALSO! This forces high count lines to be at the top of the aggregate time list, which is really important!
+// NOTE: The overhead time greatly varies, but even if it only takes 100ns, if 10X of that
+//  is significant, you are probably spending too much timing profiling anyway!
+exports.measureOverheadTime = 500 / 1000 / 1000;
+// We internally add, because of where we measure time, there is time spent before we grab the
+//  current time, and after we record the last time, that is lost, but should be added.
+let addMeasureOverheadTime = 0;
+{
+    // NOTE: This is going to vary considerably. I assume because sometimes we are on a core
+    //  that is free, and other times we are on a core that is hyperthreading with another hardware
+    //  thread. This really hurts us because our timing uses rdtsc, which really hates hyper threading,
+    //  and can easily get 50% slower because of it.
+    let results = [];
+    for (let j = 0; j < 10; j++) {
+        const measureCount = 1000 * 10;
+        let time = now();
+        for (let i = 0; i < measureCount; i++) {
+            getOwnTime("test", () => { }, () => { });
+        }
+        time = now() - time;
+        let overhead = time / measureCount;
+        results.push(overhead);
+    }
+    results.sort((a, b) => a - b);
+    addMeasureOverheadTime = results[results.length / 2];
+}
+// TIMING: About 60ns, of which 40ns is just now() calls.
+//  If async is closer to 300ns.
+// NOTE: Handles promises correctly
+function getOwnTime(name, code, onTime) {
+    let time = now();
+    let obj = {
+        name,
+        time: 0,
+        ownTime: 0,
+        firstStartTime: time,
+        lastStartTime: time,
+    };
+    let prevOwnTime = openTimes[openTimes.length - 1];
+    if (prevOwnTime) {
+        prevOwnTime.ownTime += time - prevOwnTime.lastStartTime;
+    }
+    openTimes.push(obj);
+    function finish() {
+        let time = now();
+        obj.time = time - obj.firstStartTime;
+        if (obj === openTimes[openTimes.length - 1]) {
+            obj.ownTime += time - obj.lastStartTime;
+            let newOwnTime = openTimes[openTimes.length - 2];
+            if (newOwnTime) {
+                newOwnTime.lastStartTime = time;
+            }
+        }
+        let index = openTimes.indexOf(obj);
+        openTimes.splice(index, 1);
+        obj.time += addMeasureOverheadTime;
+        obj.ownTime += addMeasureOverheadTime;
+        onTime(obj);
+    }
+    let isAsync = false;
+    try {
+        let result = code();
+        if (result && typeof result === "object" && result instanceof Promise) {
+            isAsync = true;
+            return result.finally(() => {
+                finish();
+            });
+        }
+        return result;
+    }
+    finally {
+        if (!isAsync) {
+            finish();
+        }
+    }
+}
+exports.getOwnTime = getOwnTime;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getOwnTime.js","sourceRoot":"","sources":["getOwnTime.ts"],"names":[],"mappings":"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","sourcesContent":["import debugbreak from \"debugbreak\";\nimport { isNode } from \"../misc\";\nimport { createSingleton } from \"../createSingleton\";\n// TODO: We could probably make this an optional / dev dependency, to allow\n//  for use on machines without the ability to compile?\n//import { now } from \"rdtsc-now\";\nlet now = () => performance.now();\n\nexport type OwnTimeObj = {\n    name: string;\n    time: number;\n    ownTime: number;\n};\nexport type OwnTimeObjInternal = OwnTimeObj & {\n    lastStartTime: number;\n    firstStartTime: number;\n};\n\n// Shared across every copy of this package loaded in the process, so a profile started via one\n//  copy's startMeasure nests correctly with getOwnTime calls made through another copy. The\n//  open-time stack MUST be a single instance, otherwise cross-copy nesting/own-time accounting\n//  breaks (a function wrapped by copy A calling one wrapped by copy B would push onto a different\n//  stack). See createSingleton.\nconst openTimes = createSingleton(\"measure.openTimes\", 1, () => [] as OwnTimeObjInternal[]).get();\n\nexport function getOpenTimesBase(): OwnTimeObjInternal[] {\n    return openTimes;\n}\n\n(globalThis as any).pendingOwnCallTime = openTimes;\n\n// NOTE: This overhead time is actually mostly for aggregate time, but it is needed,\n//  otherwise we consistently underestimate the time spent.\n//  ALSO! This forces high count lines to be at the top of the aggregate time list, which is really important!\n// NOTE: The overhead time greatly varies, but even if it only takes 100ns, if 10X of that\n//  is significant, you are probably spending too much timing profiling anyway!\nexport const measureOverheadTime = 500 / 1000 / 1000;\n// We internally add, because of where we measure time, there is time spent before we grab the\n//  current time, and after we record the last time, that is lost, but should be added.\nlet addMeasureOverheadTime = 0;\n{\n    // NOTE: This is going to vary considerably. I assume because sometimes we are on a core\n    //  that is free, and other times we are on a core that is hyperthreading with another hardware\n    //  thread. This really hurts us because our timing uses rdtsc, which really hates hyper threading,\n    //  and can easily get 50% slower because of it.\n    let results: number[] = [];\n    for (let j = 0; j < 10; j++) {\n        const measureCount = 1000 * 10;\n        let time = now();\n        for (let i = 0; i < measureCount; i++) {\n            getOwnTime(\"test\", () => { }, () => { });\n        }\n        time = now() - time;\n        let overhead = time / measureCount;\n        results.push(overhead);\n    }\n    results.sort((a, b) => a - b);\n    addMeasureOverheadTime = results[results.length / 2];\n}\n\n// TIMING: About 60ns, of which 40ns is just now() calls.\n//  If async is closer to 300ns.\n// NOTE: Handles promises correctly\nexport function getOwnTime<T>(\n    name: string,\n    code: () => T,\n    onTime: (obj: OwnTimeObj) => void\n): T {\n    let time = now();\n    let obj: OwnTimeObjInternal = {\n        name,\n        time: 0,\n        ownTime: 0,\n        firstStartTime: time,\n        lastStartTime: time,\n    };\n    let prevOwnTime = openTimes[openTimes.length - 1];\n    if (prevOwnTime) {\n        prevOwnTime.ownTime += time - prevOwnTime.lastStartTime;\n    }\n    openTimes.push(obj);\n\n    function finish() {\n        let time = now();\n        obj.time = time - obj.firstStartTime;\n        if (obj === openTimes[openTimes.length - 1]) {\n            obj.ownTime += time - obj.lastStartTime;\n            let newOwnTime = openTimes[openTimes.length - 2];\n            if (newOwnTime) {\n                newOwnTime.lastStartTime = time;\n            }\n        }\n        let index = openTimes.indexOf(obj);\n        openTimes.splice(index, 1);\n\n        obj.time += addMeasureOverheadTime;\n        obj.ownTime += addMeasureOverheadTime;\n\n        onTime(obj);\n    }\n\n    let isAsync = false;\n    try {\n        let result = code();\n        if (result && typeof result === \"object\" && result instanceof Promise) {\n            isAsync = true;\n            return result.finally(() => {\n                finish();\n            }) as any;\n        }\n        return result;\n    } finally {\n        if (!isAsync) {\n            finish();\n        }\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "31fb9c8c80c18465404304159fbde1a41f8ffcf4f6370d5047d3ef0f84daa04d"; */

package/src/profiling/dist/measure.ts.cache

@@ -0,0 +1,338 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.addToMeasureProfile = exports.createMeasureProfile = exports.measureCodeSync = exports.measureCode = exports.logMeasureTable = exports.startMeasure = exports.registerMeasureInfo = exports.measureBlock = exports.measureWrap = exports.nameFunction = exports.measureFnc = exports.disableMeasurements = exports.enableMeasurements = void 0;
+const format_1 = require("../formatting/format");
+const logColors_1 = require("../formatting/logColors");
+const getOwnTime_1 = require("./getOwnTime");
+const stats_1 = require("./stats");
+const misc_1 = require("../misc");
+const statsFormat_1 = require("./statsFormat");
+const createSingleton_1 = require("../createSingleton");
+// Shared across every copy of this package loaded in the process, so enable/disableMeasurements
+//  on any copy is honored by every copy's measureWrap, and so the skipped-function warning counts
+//  across all copies. Held as a mutated-in-place object because the flags are reassigned. See
+//  createSingleton.
+const measureState = (0, createSingleton_1.createSingleton)("measure.state", 1, () => ({
+    measurementsEnabled: true,
+    measurementsDisabled: false,
+    functionsSkipped: 0,
+})).get();
+/** NOTE: Must be called BEFORE anything else is imported!
+ *      NOTE: Measurements on on by default now, so this doesn't really need to be called...
+*/
+function enableMeasurements() {
+    if (measureState.functionsSkipped) {
+        console.warn((0, logColors_1.red)(`Skipped measure shimming ${measureState.functionsSkipped} functions. Fix this by calling enableMeasurements before any other imports.`));
+    }
+    measureState.measurementsEnabled = true;
+}
+exports.enableMeasurements = enableMeasurements;
+/** NOTE: Must be called BEFORE anything else is imported! */
+function disableMeasurements() {
+    measureState.measurementsEnabled = false;
+    measureState.measurementsDisabled = true;
+}
+exports.disableMeasurements = disableMeasurements;
+const measureOverhead = 5 / 1000;
+const AsyncFunction = (async () => { }).constructor;
+// NOTE: Also hardcoded in diskLogger.ts (in querysub)
+const noDiskLogPrefix = "█ ";
+// TIMING: 1-5us. I have seen timing values greatly vary, but it does seem to be quite high, despite
+//  microbenchmarks saying it is slow. Perhaps it is because getOwnTime breaks the cpu pipeline,
+//  which causes slowness for code around us, but not if we are running in isolation?
+// NOTE: Handles promises correctly
+function measureFnc(target, propertyKey, descriptor) {
+    let name = propertyKey;
+    if (target.name) {
+        name = `${target.name}|${name}`;
+    }
+    else {
+        let constructorName = target.constructor.name;
+        if (constructorName) {
+            name = `${constructorName}()|${name}`;
+        }
+    }
+    if (descriptor.value instanceof AsyncFunction) {
+        name += `(async)`;
+    }
+    descriptor.value = measureWrap(descriptor.value, name);
+}
+exports.measureFnc = measureFnc;
+// https://stackoverflow.com/questions/5905492/dynamic-function-name-in-javascript
+function nameFunction(name, fnc) {
+    Object.defineProperty(fnc, "name", { value: name });
+    return fnc;
+}
+exports.nameFunction = nameFunction;
+// NOTE: Handles promises correctly
+function measureWrap(fnc, name) {
+    if (!measureState.measurementsEnabled) {
+        measureState.functionsSkipped++;
+        return fnc;
+    }
+    let usedName = name || fnc.name || fnc.toString().slice(0, 100).replaceAll(/\s/g, " ");
+    let output = nameFunction(usedName, (function (...args) {
+        if (outstandingProfiles.length === 0) {
+            return fnc.apply(this, args);
+        }
+        return (0, getOwnTime_1.getOwnTime)(usedName, () => fnc.apply(this, args), recordOwnTime);
+    }));
+    output.originalFnc = fnc;
+    return output;
+}
+exports.measureWrap = measureWrap;
+function measureBlock(fnc, name) {
+    return measureWrap(fnc, name)();
+}
+exports.measureBlock = measureBlock;
+// Shared across copies so registerMeasureInfo on any copy is seen by logMeasureTable. See createSingleton.
+const extraInfoGetters = (0, createSingleton_1.createSingleton)("measure.extraInfoGetters", 1, () => []).get();
+/** NOTE: You should often call registerNodeMetadata for this as well. registerMeasureInfo
+ *      is for logs, while registerNodeMetadata is for the overview page.
+ */
+function registerMeasureInfo(getInfo) {
+    extraInfoGetters.push(getInfo);
+}
+exports.registerMeasureInfo = registerMeasureInfo;
+/** IMPORTANT! Always finish the profile! If you don't, you will leak A LOT of memory
+ *      (you leak all future measures, PER unfinished profile)!
+ */
+function startMeasure() {
+    if (!measureState.measurementsEnabled && !measureState.measurementsDisabled) {
+        console.warn((0, logColors_1.red)(`To capture measurements enableMeasurements() must be called before any other imports in your entry point`));
+    }
+    let now = Date.now();
+    let profile = {
+        startTime: now,
+        endTime: now,
+        entries: Object.create(null),
+        creator: new Error().stack || "",
+    };
+    let openAtStart = new Set((0, getOwnTime_1.getOpenTimesBase)());
+    outstandingProfiles.push(profile);
+    if (outstandingProfiles.length > 1000) {
+        console.warn((0, logColors_1.red)(`You have ${outstandingProfiles.length} outstanding startMeasure calls. You are probably leaking them!`));
+    }
+    return {
+        finish() {
+            let pending = (0, getOwnTime_1.getOpenTimesBase)();
+            let last = pending[pending.length - 1];
+            let time = Date.now();
+            for (let timeObj of pending) {
+                // Ignore any values that were already open, as they are clearly not
+                //  caused by our code.
+                if (openAtStart.has(timeObj))
+                    continue;
+                timeObj = { ...timeObj };
+                if (timeObj === last) {
+                    timeObj.ownTime += time - timeObj.lastStartTime;
+                }
+                timeObj.time = time - timeObj.firstStartTime;
+                addToProfile(profile, timeObj);
+            }
+            outstandingProfiles.splice(outstandingProfiles.indexOf(profile), 1);
+            profile.endTime = Date.now();
+            return profile;
+        }
+    };
+}
+exports.startMeasure = startMeasure;
+function logMeasureTable(profile, config) {
+    var _a, _b, _c, _d;
+    let { useTotalTime, name } = config || {};
+    const thresholdInTable = (_a = config === null || config === void 0 ? void 0 : config.thresholdInTable) !== null && _a !== void 0 ? _a : 0.02;
+    let minTimeToLog = (_b = config === null || config === void 0 ? void 0 : config.minTimeToLog) !== null && _b !== void 0 ? _b : 20;
+    const maxTableEntries = (_c = config === null || config === void 0 ? void 0 : config.maxTableEntries) !== null && _c !== void 0 ? _c : 10;
+    function getTime(entry) {
+        return useTotalTime ? entry.totalTime : entry.ownTime;
+    }
+    let entries = Object.values(profile.entries);
+    entries.sort((a, b) => getTime(b).sum - getTime(a).sum);
+    let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
+    if (totalTime < minTimeToLog)
+        return undefined;
+    let mergeDepth = (_d = config === null || config === void 0 ? void 0 : config.mergeDepth) !== null && _d !== void 0 ? _d : 2;
+    {
+        let merged = new Map();
+        for (let entry of entries) {
+            let parts = entry.name.split("|");
+            let key = parts.slice(0, mergeDepth).join("|");
+            let existing = merged.get(key);
+            if (!existing) {
+                existing = { name: key, ownTime: (0, stats_1.createStatsValue)(), totalTime: (0, stats_1.createStatsValue)(), stillOpenCount: 0 };
+                merged.set(key, existing);
+            }
+            (0, stats_1.addToStats)(existing.ownTime, entry.ownTime);
+            (0, stats_1.addToStats)(existing.totalTime, entry.totalTime);
+            existing.stillOpenCount += entry.stillOpenCount;
+        }
+        entries = Array.from(merged.values());
+        entries.sort((a, b) => getTime(b).sum - getTime(a).sum);
+    }
+    let timeRunFor = profile.endTime - profile.startTime;
+    let fraction = totalTime / timeRunFor;
+    console.log();
+    let extraInfos = extraInfoGetters.map(x => x());
+    if ((config === null || config === void 0 ? void 0 : config.setTitle) && (0, misc_1.isNode)()) {
+        let title = `${percent(fraction)} CPU`;
+        title += extraInfos.map(x => x ? ` // ${x}` : "").join("");
+        process.stdout.write(`\x1b]0;${title}\x07`);
+    }
+    let pid = (0, misc_1.isNode)() ? `(${process.pid}) ` : "";
+    let title = (0, logColors_1.yellow)(`${pid}Profiled ${(0, format_1.formatTime)(totalTime)} (${percent(fraction)} CPU)${extraInfos.map(x => x ? ` (${x})` : "").filter(x => x).join(" |")} (logged at ${new Date().toISOString()}, profile for ${(0, format_1.formatTime)(timeRunFor)})`);
+    if (name) {
+        title = `(${(0, logColors_1.blue)(name)}) ${title}`;
+    }
+    console.log(noDiskLogPrefix + title);
+    function percent(value) {
+        return `${(value * 100).toFixed(2)}%`;
+    }
+    let remaining = entries.slice(maxTableEntries);
+    entries = entries.slice(0, maxTableEntries);
+    entries = entries.filter(entry => {
+        const include = getTime(entry).sum / totalTime >= thresholdInTable;
+        if (!include) {
+            remaining.push(entry);
+        }
+        return include;
+    });
+    entries.push({
+        name: "Other",
+        ownTime: (0, stats_1.createStatsValue)(),
+        totalTime: (0, stats_1.createStatsValue)(),
+        stillOpenCount: 0,
+    });
+    let remainingEntry = entries[entries.length - 1];
+    for (let entry of remaining) {
+        (0, stats_1.addToStats)(remainingEntry.ownTime, entry.ownTime);
+        (0, stats_1.addToStats)(remainingEntry.totalTime, entry.totalTime);
+        remainingEntry.stillOpenCount += entry.stillOpenCount;
+    }
+    let maxNameLength = Math.max(...entries.map(x => x.name.length));
+    for (let entry of entries) {
+        let output = "";
+        output += `${(0, logColors_1.blue)(entry.name)}`;
+        output += Array(maxNameLength + 4 - entry.name.length).fill(" ").join("");
+        function p(count, text) {
+            return String(text).padStart(count, " ");
+        }
+        let fractionText = percent(getTime(entry).sum / totalTime);
+        let equation = (0, statsFormat_1.formatStats)(getTime(entry));
+        let text = `${p(6, fractionText)} ( ${equation} )`;
+        let overhead = measureOverhead * getTime(entry).count;
+        let overheadFraction = overhead / getTime(entry).sum;
+        let overheadIsAProblem = overheadFraction > 0.5;
+        if (overheadIsAProblem) {
+            text = (0, logColors_1.yellow)(text);
+        }
+        output += text;
+        if (overheadIsAProblem) {
+            output += (0, logColors_1.red)(`    measurement overhead is ~${percent(overheadFraction)} of the time.`);
+        }
+        if (entry.stillOpenCount > 0) {
+            output += (0, logColors_1.red)(`    (${entry.stillOpenCount} open)`);
+        }
+        console.log(noDiskLogPrefix + output);
+    }
+    console.log();
+    return {
+        title,
+        entries: entries.map(entry => {
+            let time = getTime(entry);
+            let fraction = time.sum / totalTime;
+            return {
+                name: entry.name,
+                ownTime: time.sum,
+                fraction,
+                equation: (0, statsFormat_1.formatStats)(time),
+            };
+        })
+    };
+}
+exports.logMeasureTable = logMeasureTable;
+async function measureCode(code, config) {
+    let measure = startMeasure();
+    try {
+        return await measureBlock(code, code.name || "untracked");
+    }
+    finally {
+        finishProfile(measure, config || { name: code.name, minTimeToLog: 0 });
+    }
+}
+exports.measureCode = measureCode;
+function measureCodeSync(code, config) {
+    let measure = startMeasure();
+    try {
+        return measureBlock(code, code.name || "untracked");
+    }
+    finally {
+        finishProfile(measure, config);
+    }
+}
+exports.measureCodeSync = measureCodeSync;
+function finishProfile(measure, config) {
+    let profile = measure.finish();
+    logMeasureTable(profile, config);
+}
+function createMeasureProfile() {
+    let now = Date.now();
+    return {
+        startTime: now,
+        endTime: now,
+        entries: Object.create(null),
+        creator: new Error().stack || "",
+    };
+}
+exports.createMeasureProfile = createMeasureProfile;
+function addToMeasureProfile(base, other) {
+    for (let name in other.entries) {
+        let entry = other.entries[name];
+        let baseEntry = base.entries[name];
+        if (!baseEntry) {
+            baseEntry = {
+                name: name,
+                ownTime: (0, stats_1.createStatsValue)(),
+                totalTime: (0, stats_1.createStatsValue)(),
+                stillOpenCount: 0,
+            };
+            base.entries[name] = baseEntry;
+        }
+        (0, stats_1.addToStats)(baseEntry.ownTime, entry.ownTime);
+        (0, stats_1.addToStats)(baseEntry.totalTime, entry.totalTime);
+        baseEntry.stillOpenCount += entry.stillOpenCount;
+    }
+}
+exports.addToMeasureProfile = addToMeasureProfile;
+// Shared across copies so a profile started through one copy captures measureWrap'd functions from
+//  every other copy - otherwise a profile would only ever see functions wrapped by its own copy.
+//  See createSingleton.
+const outstandingProfiles = (0, createSingleton_1.createSingleton)("measure.outstandingProfiles", 1, () => []).get();
+globalThis.outstandingProfiles = outstandingProfiles;
+function recordOwnTime(ownTimeObj) {
+    if (outstandingProfiles.length === 0)
+        return;
+    for (let i = 0; i < outstandingProfiles.length; i++) {
+        let profile = outstandingProfiles[i];
+        addToProfile(profile, ownTimeObj);
+    }
+}
+function addToProfile(profile, ownTimeObj, stillOpen) {
+    let name = ownTimeObj.name;
+    let entry = profile.entries[name];
+    if (!entry) {
+        entry = {
+            name: name,
+            ownTime: (0, stats_1.createStatsValue)(),
+            totalTime: (0, stats_1.createStatsValue)(),
+            stillOpenCount: 0,
+        };
+        profile.entries[name] = entry;
+    }
+    (0, stats_1.addToStatsValue)(entry.ownTime, ownTimeObj.ownTime);
+    (0, stats_1.addToStatsValue)(entry.totalTime, ownTimeObj.time);
+    if (stillOpen) {
+        entry.stillOpenCount++;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measure.js","sourceRoot":"","sources":["measure.ts"],"names":[],"mappings":"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","sourcesContent":["import debugbreak from \"debugbreak\";\nimport { formatTime, formatNumber } from \"../formatting/format\";\nimport { red, yellow, blue, magenta } from \"../formatting/logColors\";\n\nimport { getOpenTimesBase, getOwnTime, OwnTimeObj } from \"./getOwnTime\";\nimport { addToStats, addToStatsValue, createStatsValue, getStatsTop, StatsValue } from \"./stats\";\nimport { white } from \"../formatting/logColors\";\nimport { isNode } from \"../misc\";\nimport { formatStats, percent } from \"./statsFormat\";\nimport { createSingleton } from \"../createSingleton\";\n\n// Shared across every copy of this package loaded in the process, so enable/disableMeasurements\n//  on any copy is honored by every copy's measureWrap, and so the skipped-function warning counts\n//  across all copies. Held as a mutated-in-place object because the flags are reassigned. See\n//  createSingleton.\nconst measureState = createSingleton(\"measure.state\", 1, () => ({\n    measurementsEnabled: true,\n    measurementsDisabled: false,\n    functionsSkipped: 0,\n})).get();\n/** NOTE: Must be called BEFORE anything else is imported!\n *      NOTE: Measurements on on by default now, so this doesn't really need to be called...\n*/\nexport function enableMeasurements() {\n    if (measureState.functionsSkipped) {\n        console.warn(red(`Skipped measure shimming ${measureState.functionsSkipped} functions. Fix this by calling enableMeasurements before any other imports.`));\n    }\n    measureState.measurementsEnabled = true;\n}\n/** NOTE: Must be called BEFORE anything else is imported! */\nexport function disableMeasurements() {\n    measureState.measurementsEnabled = false;\n    measureState.measurementsDisabled = true;\n}\n\nconst measureOverhead = 5 / 1000;\n\nconst AsyncFunction = (async () => { }).constructor;\n\n// NOTE: Also hardcoded in diskLogger.ts (in querysub)\nconst noDiskLogPrefix = \"█ \";\n\n// TIMING: 1-5us. I have seen timing values greatly vary, but it does seem to be quite high, despite\n//  microbenchmarks saying it is slow. Perhaps it is because getOwnTime breaks the cpu pipeline,\n//  which causes slowness for code around us, but not if we are running in isolation?\n// NOTE: Handles promises correctly\nexport function measureFnc(target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n    let name = propertyKey;\n    if (target.name) {\n        name = `${target.name}|${name}`;\n    } else {\n        let constructorName = target.constructor.name;\n        if (constructorName) {\n            name = `${constructorName}()|${name}`;\n        }\n    }\n    if (descriptor.value instanceof AsyncFunction) {\n        name += `(async)`;\n    }\n    descriptor.value = measureWrap(descriptor.value, name);\n}\n\n// https://stackoverflow.com/questions/5905492/dynamic-function-name-in-javascript\nexport function nameFunction<T extends Function>(name: string, fnc: T) {\n    Object.defineProperty(fnc, \"name\", { value: name });\n    return fnc;\n}\n// NOTE: Handles promises correctly\nexport function measureWrap<T extends (...args: any[]) => any>(fnc: T, name?: string): T {\n    if (!measureState.measurementsEnabled) {\n        measureState.functionsSkipped++;\n        return fnc;\n    }\n    let usedName = name || fnc.name || fnc.toString().slice(0, 100).replaceAll(/\\s/g, \" \");\n    let output = nameFunction(usedName, (function (this: any, ...args: unknown[]): unknown {\n        if (outstandingProfiles.length === 0) {\n            return fnc.apply(this, args);\n        }\n        return getOwnTime(usedName, () => fnc.apply(this, args), recordOwnTime);\n    })) as T;\n    (output as any).originalFnc = fnc;\n    return output;\n}\nexport function measureBlock<T extends (...args: any[]) => any>(fnc: T, name?: string): ReturnType<T> {\n    return measureWrap(fnc, name)();\n}\n\n// Shared across copies so registerMeasureInfo on any copy is seen by logMeasureTable. See createSingleton.\nconst extraInfoGetters = createSingleton(\"measure.extraInfoGetters\", 1, () => [] as (() => string | undefined)[]).get();\n/** NOTE: You should often call registerNodeMetadata for this as well. registerMeasureInfo\n *      is for logs, while registerNodeMetadata is for the overview page.\n */\nexport function registerMeasureInfo(getInfo: () => string | undefined) {\n    extraInfoGetters.push(getInfo);\n}\n\n/** IMPORTANT! Always finish the profile! If you don't, you will leak A LOT of memory\n *      (you leak all future measures, PER unfinished profile)!\n */\nexport function startMeasure(): {\n    finish: () => MeasureProfile;\n} {\n    if (!measureState.measurementsEnabled && !measureState.measurementsDisabled) {\n        console.warn(red(`To capture measurements enableMeasurements() must be called before any other imports in your entry point`));\n    }\n    let now = Date.now();\n    let profile: MeasureProfile = {\n        startTime: now,\n        endTime: now,\n        entries: Object.create(null),\n        creator: new Error().stack || \"\",\n    };\n    let openAtStart = new Set(getOpenTimesBase());\n\n    outstandingProfiles.push(profile);\n    if (outstandingProfiles.length > 1000) {\n        console.warn(red(`You have ${outstandingProfiles.length} outstanding startMeasure calls. You are probably leaking them!`));\n    }\n    return {\n        finish() {\n            let pending = getOpenTimesBase();\n            let last = pending[pending.length - 1];\n            let time = Date.now();\n            for (let timeObj of pending) {\n                // Ignore any values that were already open, as they are clearly not\n                //  caused by our code.\n                if (openAtStart.has(timeObj)) continue;\n                timeObj = { ...timeObj };\n\n                if (timeObj === last) {\n                    timeObj.ownTime += time - timeObj.lastStartTime;\n                }\n                timeObj.time = time - timeObj.firstStartTime;\n                addToProfile(profile, timeObj);\n            }\n            outstandingProfiles.splice(outstandingProfiles.indexOf(profile), 1);\n            profile.endTime = Date.now();\n            return profile;\n        }\n    };\n}\n\nexport interface LogMeasureTableConfig {\n    useTotalTime?: boolean;\n    name?: string;\n    setTitle?: boolean;\n    // Defaults to 0.05\n    thresholdInTable?: number;\n    // Details to 50\n    minTimeToLog?: number;\n    // Defaults to 2\n    mergeDepth?: number;\n    // Defaults to 10\n    maxTableEntries?: number;\n\n    // No logging, just returns FormattedMeasureTable\n    returnOnly?: boolean;\n}\n\nexport interface FormattedMeasureTable {\n    title: string;\n    entries: {\n        name: string;\n        ownTime: number;\n        fraction: number;\n        equation: string;\n    }[];\n}\n\nexport function logMeasureTable(\n    profile: MeasureProfile,\n    config?: LogMeasureTableConfig\n): FormattedMeasureTable | undefined {\n    let { useTotalTime, name } = config || {};\n    const thresholdInTable = config?.thresholdInTable ?? 0.02;\n    let minTimeToLog = config?.minTimeToLog ?? 20;\n    const maxTableEntries = config?.maxTableEntries ?? 10;\n\n    function getTime(entry: ProfileEntry) {\n        return useTotalTime ? entry.totalTime : entry.ownTime;\n    }\n    let entries = Object.values(profile.entries);\n    entries.sort((a, b) => getTime(b).sum - getTime(a).sum);\n\n    let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);\n    if (totalTime < minTimeToLog) return undefined;\n\n    let mergeDepth = config?.mergeDepth ?? 2;\n    {\n        let merged = new Map<string, ProfileEntry>();\n        for (let entry of entries) {\n            let parts = entry.name.split(\"|\");\n            let key = parts.slice(0, mergeDepth).join(\"|\");\n            let existing = merged.get(key);\n            if (!existing) {\n                existing = { name: key, ownTime: createStatsValue(), totalTime: createStatsValue(), stillOpenCount: 0 };\n                merged.set(key, existing);\n            }\n            addToStats(existing.ownTime, entry.ownTime);\n            addToStats(existing.totalTime, entry.totalTime);\n            existing.stillOpenCount += entry.stillOpenCount;\n        }\n        entries = Array.from(merged.values());\n        entries.sort((a, b) => getTime(b).sum - getTime(a).sum);\n    }\n\n    let timeRunFor = profile.endTime - profile.startTime;\n    let fraction = totalTime / timeRunFor;\n\n    console.log();\n    let extraInfos = extraInfoGetters.map(x => x());\n\n    if (config?.setTitle && isNode()) {\n        let title = `${percent(fraction)} CPU`;\n        title += extraInfos.map(x => x ? ` // ${x}` : \"\").join(\"\");\n        process.stdout.write(`\\x1b]0;${title}\\x07`);\n    }\n    let pid = isNode() ? `(${process.pid}) ` : \"\";\n    let title = yellow(`${pid}Profiled ${formatTime(totalTime)} (${percent(fraction)} CPU)${extraInfos.map(x => x ? ` (${x})` : \"\").filter(x => x).join(\" |\")} (logged at ${new Date().toISOString()}, profile for ${formatTime(timeRunFor)})`);\n    if (name) {\n        title = `(${blue(name)}) ${title}`;\n    }\n    console.log(noDiskLogPrefix + title);\n    function percent(value: number) {\n        return `${(value * 100).toFixed(2)}%`;\n    }\n\n    let remaining = entries.slice(maxTableEntries);\n    entries = entries.slice(0, maxTableEntries);\n    entries = entries.filter(entry => {\n        const include = getTime(entry).sum / totalTime >= thresholdInTable;\n        if (!include) {\n            remaining.push(entry);\n        }\n        return include;\n    });\n    entries.push({\n        name: \"Other\",\n        ownTime: createStatsValue(),\n        totalTime: createStatsValue(),\n        stillOpenCount: 0,\n    });\n    let remainingEntry = entries[entries.length - 1];\n    for (let entry of remaining) {\n        addToStats(remainingEntry.ownTime, entry.ownTime);\n        addToStats(remainingEntry.totalTime, entry.totalTime);\n        remainingEntry.stillOpenCount += entry.stillOpenCount;\n    }\n    let maxNameLength = Math.max(...entries.map(x => x.name.length));\n\n    for (let entry of entries) {\n        let output = \"\";\n        output += `${blue(entry.name)}`;\n        output += Array(maxNameLength + 4 - entry.name.length).fill(\" \").join(\"\");\n\n        function p(count: number, text: string | number) {\n            return String(text).padStart(count, \" \");\n        }\n        let fractionText = percent(getTime(entry).sum / totalTime);\n\n        let equation = formatStats(getTime(entry));\n\n        let text = `${p(6, fractionText)} ( ${equation} )`;\n        let overhead = measureOverhead * getTime(entry).count;\n        let overheadFraction = overhead / getTime(entry).sum;\n        let overheadIsAProblem = overheadFraction > 0.5;\n        if (overheadIsAProblem) {\n            text = yellow(text);\n        }\n\n        output += text;\n\n        if (overheadIsAProblem) {\n            output += red(`    measurement overhead is ~${percent(overheadFraction)} of the time.`);\n        }\n\n        if (entry.stillOpenCount > 0) {\n            output += red(`    (${entry.stillOpenCount} open)`);\n        }\n\n        console.log(noDiskLogPrefix + output);\n    }\n    console.log();\n\n    return {\n        title,\n        entries: entries.map(entry => {\n            let time = getTime(entry);\n            let fraction = time.sum / totalTime;\n            return {\n                name: entry.name,\n                ownTime: time.sum,\n                fraction,\n                equation: formatStats(time),\n            };\n        })\n    };\n}\n\nexport async function measureCode<T>(code: () => Promise<T>, config?: LogMeasureTableConfig) {\n    let measure = startMeasure();\n    try {\n        return await measureBlock(code, code.name || \"untracked\");\n    } finally {\n        finishProfile(measure, config || { name: code.name, minTimeToLog: 0 });\n    }\n}\nexport function measureCodeSync<T>(code: () => T, config?: LogMeasureTableConfig): T {\n    let measure = startMeasure();\n    try {\n        return measureBlock(code, code.name || \"untracked\");\n    } finally {\n        finishProfile(measure, config);\n    }\n}\nfunction finishProfile(measure: { finish(): MeasureProfile }, config?: LogMeasureTableConfig) {\n    let profile = measure.finish();\n    logMeasureTable(profile, config);\n}\n\n\nexport interface MeasureProfile {\n    startTime: number;\n    endTime: number;\n    entries: {\n        [name: string]: ProfileEntry;\n    };\n    creator: string;\n}\nexport function createMeasureProfile(): MeasureProfile {\n    let now = Date.now();\n    return {\n        startTime: now,\n        endTime: now,\n        entries: Object.create(null),\n        creator: new Error().stack || \"\",\n    };\n}\n\nexport function addToMeasureProfile(base: MeasureProfile, other: MeasureProfile) {\n    for (let name in other.entries) {\n        let entry = other.entries[name];\n        let baseEntry = base.entries[name];\n        if (!baseEntry) {\n            baseEntry = {\n                name: name,\n                ownTime: createStatsValue(),\n                totalTime: createStatsValue(),\n                stillOpenCount: 0,\n            };\n            base.entries[name] = baseEntry;\n        }\n        addToStats(baseEntry.ownTime, entry.ownTime);\n        addToStats(baseEntry.totalTime, entry.totalTime);\n        baseEntry.stillOpenCount += entry.stillOpenCount;\n    }\n}\n\ninterface ProfileEntry {\n    name: string;\n    ownTime: StatsValue;\n    totalTime: StatsValue;\n    stillOpenCount: number;\n}\n\n// Shared across copies so a profile started through one copy captures measureWrap'd functions from\n//  every other copy - otherwise a profile would only ever see functions wrapped by its own copy.\n//  See createSingleton.\nconst outstandingProfiles = createSingleton(\"measure.outstandingProfiles\", 1, () => [] as MeasureProfile[]).get();\n(globalThis as any).outstandingProfiles = outstandingProfiles;\nfunction recordOwnTime(ownTimeObj: OwnTimeObj) {\n    if (outstandingProfiles.length === 0) return;\n    for (let i = 0; i < outstandingProfiles.length; i++) {\n        let profile = outstandingProfiles[i];\n        addToProfile(profile, ownTimeObj);\n    }\n}\n\n\nfunction addToProfile(profile: MeasureProfile, ownTimeObj: OwnTimeObj, stillOpen?: boolean) {\n    let name = ownTimeObj.name;\n    let entry = profile.entries[name];\n    if (!entry) {\n        entry = {\n            name: name,\n            ownTime: createStatsValue(),\n            totalTime: createStatsValue(),\n            stillOpenCount: 0,\n        };\n        profile.entries[name] = entry;\n    }\n    addToStatsValue(entry.ownTime, ownTimeObj.ownTime);\n    addToStatsValue(entry.totalTime, ownTimeObj.time);\n    if (stillOpen) {\n        entry.stillOpenCount++;\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "04519135586427254303562b9fb7098c4df1167003b034ecece33ace1e3f0d11"; */