ritmex-bot/docs/ccxt/wiki/examples/ts/benchmark.md

- [Benchmark](./examples/ts/)


 ```javascript
 import { spawn } from 'child_process';
import asTable from 'as-table';
import ccxt, { version } from '../../js/ccxt.js';

interface Stats {
    min: number;
    average: number;
    max: number;
    median: number;
    iterations: number;
}

interface Test {
    language: string;
    method: string;
    command: string;
}

interface Benchmark extends Omit<Test, 'command'>, Stats { }

const stats = (times: number[]): Stats => {
    // 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: Test[] = 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: Test[] = 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: string) {
        if (verbose) {
            console.log (exchange.iso8601 (new Date ().getTime ()), ' running command:', command);
        }
        return new Promise<{ times: number[] }> ((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: Buffer) => {
                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: Buffer) => {
                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: number) => {
                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: Benchmark[] = [];
    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);
 
```