Benchmark

import { spawn } from 'child_process';
import asTable from 'as-table';
import ccxt, { version } from '../../js/ccxt.js';
const stats = (times) => {
    // calculate statistics
    const sum = times.reduce((a, b) => a + b, 0);
    const avg = Math.round(sum / times.length);
    const min = Math.min(...times);
    const max = Math.max(...times);
    times.sort((a, b) => a - b);
    const median = times.length % 2 === 0 ? (times[times.length / 2 - 1] + times[times.length / 2]) / 2 : times[Math.floor(times.length / 2)];
    return { min, 'average': avg, max, median, 'iterations': times.length };
};
async function benchmark(exchangeId, method, args, verbose = false, minIterations = 10, argsv = '') {
    const exchange = new ccxt.pro[exchangeId]({});
    const languages = ['js', 'py', 'php', 'cs'];
    const commands = languages.map((language) => ({
        'language': language,
        'method': method,
        'command': `npm run cli.${language} ${exchangeId} ${method} ${args.join(' ')} -- ${argsv} --poll`,
    }));
    const wsMethod = method + 'Ws';
    if (exchange.has[wsMethod]) {
        const wsCommands = languages.map((language) => ({
            'language': language,
            'method': wsMethod,
            'command': `npm run cli.${language} ${exchangeId} ${wsMethod} ${args.join(' ')} -- ${argsv} --poll`,
        }));
        commands.push(...wsCommands);
    }
    const regex = /iteration (\d+) passed in (\d+) ms/g;
    async function runCommand(command) {
        if (verbose) {
            console.log(exchange.iso8601(new Date().getTime()), ' running command:', command);
        }
        return new Promise((resolve, reject) => {
            const [cmd, ...args] = command.split(' ');
            const child = spawn(cmd, args);
            const matches = [];
            const language = command.slice(8, 15);
            child.stdout.on('data', (data) => {
                const message = data.toString();
                matches.push(...Array.from(message.matchAll(regex)));
                const match = matches[matches.length - 1];
                if (match && match[1] && match[2]) {
                    const iteration = parseInt(match[1]);
                    const time = parseInt(match[2]);
                    if (iteration <= minIterations) {
                        if (verbose) {
                            console.log(exchange.iso8601(new Date().getTime()), `${language} iteration ${iteration} passed in ${time} ms`);
                        }
                    }
                    else {
                        const times = matches.map((m) => parseInt(m[2]));
                        child.kill();
                        if (verbose) {
                            console.log(exchange.iso8601(new Date().getTime()), `killed process - ${language} iteration ${iteration} passed in ${time} ms`);
                        }
                        resolve({ times });
                    }
                }
            });
            child.stderr.on('data', (data) => {
                const message = data.toString();
                console.error(exchange.iso8601(new Date().getTime()), `command ${command} failed. stderr: ${message}`);
                const times = matches.map((m) => parseInt(m[2]));
                resolve({ times });
            });
            child.on('close', (code) => {
                const times = matches.map((m) => parseInt(m[2]));
                resolve({ times });
                console.log(exchange.iso8601(new Date().getTime()), `${language} child process exited with code ${code}`);
            });
            child.on('error', (err) => {
                console.error(exchange.iso8601(new Date().getTime()), `command ${command} failed. error: ${err}`);
                reject(err);
            });
        });
    }
    const benchmarks = [];
    const results = await Promise.all(commands.map((c) => runCommand(c.command)));
    for (let i = 0; i < results.length; i++) {
        const result = results[i];
        benchmarks.push({ 'language': commands[i].language, 'method': commands[i].method, ...stats(result.times) });
    }
    if (verbose) {
        const rawResults = results.map((r, i) => ({ 'language': commands[i].language, 'method': commands[i].method, ...stats(r.times), 'times': r.times }));
        console.log(rawResults);
    }
    console.log(asTable(benchmarks));
}
const [_, , exchangeId, methodName, ...params] = process.argv.filter((x) => !x.startsWith('--'));
const verbose = process.argv.includes('--verbose');
const minIterationsString = process.argv.find((x) => x.startsWith('--min-iterations='))?.slice(18);
const minIterations = minIterationsString ? parseInt(minIterationsString) : 10;
const argsv = process.argv.filter((x) => x.startsWith('--') && !x.startsWith('--min-iterations')).join(' ');
console.log((new Date()).toISOString());
console.log('Node.js:', process.version);
console.log('CCXT v' + version);
const start = new Date().getTime();
await benchmark(exchangeId, methodName, params, verbose, minIterations, argsv);
const end = new Date().getTime();
console.log((new Date().toISOString()), 'Total time:', end - start, 'ms');
process.exit(0);