iso-bench/lib/Test.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Test = void 0;
const Fork_1 = require("./Fork");
const Messager_1 = require("./Messager");
const getDiff_1 = require("./getDiff");
class ForkContext {
    _test;
    _processors;
    _resolve;
    _benchName;
    _options;
    _ended = false;
    constructor(_test, _processors, _resolve, _benchName, _options) {
        this._test = _test;
        this._processors = _processors;
        this._resolve = _resolve;
        this._benchName = _benchName;
        this._options = _options;
    }
    start() {
        const setup = {
            testIndex: this._test.index,
            benchName: this._benchName,
            samples: Math.min(Math.ceil(this._options.samples * 0.1), this._options.samples - this._test.samples.length),
            time: this._options.time
        };
        const worker = Fork_1.Fork.fork({
            ["ISO_BENCH_SETUP"]: JSON.stringify(setup)
        });
        this._listenForCompletionMessage(worker.stdio[3]);
        this._listenForProcessExit(worker);
    }
    _processMessage(msg) {
        if (!this._ended) {
            if (msg.error != null) {
                this._test.opMs = 0;
                this._test.error = msg.error;
                this._ended = true;
                this._resolve();
            }
            else if (msg.done) {
                this._ended = true;
                if (this._test.samples.length >= this._options.samples) {
                    this._resolve();
                }
                else {
                    new ForkContext(this._test, this._processors, this._resolve, this._benchName, this._options).start();
                }
            }
            else {
                const sample = {
                    cycles: msg.cycles,
                    time: msg.diff,
                    ops: msg.cycles / msg.diff
                };
                this._test.samples.push(sample);
                this._test.totalTime += msg.diff;
                this._test.opMs = this._test.samples.reduce((total, sample) => total + sample.ops, 0) / this._test.samples.length;
                for (const processor of this._processors) {
                    processor.sample && processor.sample(this._test, sample);
                }
            }
        }
    }
    _listenForCompletionMessage(stream) {
        let size = null;
        stream.on("readable", () => {
            try {
                while (stream.readable) {
                    if (this._ended) {
                        break;
                    }
                    else if (size == null) {
                        const buffer = stream.read(2);
                        if (buffer && buffer.length === 2) {
                            size = buffer.readUint16LE();
                        }
                        else {
                            break;
                        }
                    }
                    else {
                        const buffer = stream.read(size);
                        if (buffer && buffer.length === size) {
                            size = null;
                            const message = JSON.parse(String(buffer));
                            this._processMessage(message);
                        }
                    }
                }
            }
            catch (e) {
                this._processMessage({
                    error: String(e)
                });
            }
        });
    }
    _listenForProcessExit(worker) {
        const errBuffer = [];
        worker.stderr.on("data", data => errBuffer.push(data));
        worker.on("exit", (code) => {
            let err = `Process ended prematurely. Exit code: ${code}`;
            if (errBuffer.length > 0) {
                err = `${err}. Error: ${Buffer.concat(errBuffer).toString()}`;
            }
            this._processMessage({
                error: err
            });
        });
    }
}
class Test {
    name;
    index;
    _callback;
    _setup;
    error = null;
    opMs = 0;
    totalTime = 0;
    samples = [];
    group = "";
    constructor(name, index, _callback, _setup) {
        this.name = name;
        this.index = index;
        this._callback = _callback;
        this._setup = _setup;
    }
    fork(benchName, processors, options) {
        return new Promise((resolve => {
            const forkContext = new ForkContext(this, processors, resolve, benchName, options);
            forkContext.start();
        }));
    }
    async run(setup) {
        (0, getDiff_1.getDiff)(1, this._callback, this._setup);
        let cycles = 1;
        let samples = setup.samples;
        while (samples > 0) {
            const diff = (0, getDiff_1.getDiff)(cycles, this._callback, this._setup);
            if (diff >= setup.time) {
                samples--;
                await Messager_1.Messager.send({
                    diff: diff,
                    cycles: cycles
                });
            }
            const ratio = diff > 0 ? (setup.time / diff) * 1.02 : 1.1;
            cycles = diff >= setup.time ? Math.round(cycles * ratio) : Math.ceil(cycles * ratio);
        }
    }
}
exports.Test = Test;