view release on metacpan or  search on metacpan

dkbench  view on Meta::CPAN

#!/usr/bin/env perl

=head1 NAME

dkbench - DKbench Perl Benchmark launch script

=head1 DESCRIPTION

This is the benchmarking script, part of the L<Benchmark::DKbench> distribution.

See POD on the main module for info:

 perldoc Benchmark::DKbench

=head1 SYNOPSIS

 dkbench [options]

 Options:
 --threads <i>,  -j <i> : Number of benchmark threads (default is 1).
 --multi,        -m     : Multi-threaded using all your CPU cores/threads.
 --max_threads <i>      : Override the CPU detection to specify max CPU threads.
 --iter <i>,     -i <i> : Number of suite iterations (with min/max/avg at the end).
 --stdev                : Show relative standard deviation (for iter > 1).
 --include <regex>      : Run only benchmarks that match regex.
 --exclude <regex>      : Do not run benchmarks that match regex.
 --time,         -t     : Report time (sec) instead of score.
 --quick,        -q     : Quick benchmark run (implies -t).
 --no_mce               : Do not run under MCE::Loop (implies -j 1).
 --scale <i>,    -s <i> : Scale the bench workload by x times (incompatible with -q).
 --skip_bio             : Skip BioPerl benchmarks.
 --skip_prove           : Skip Moose prove benchmark.
 --time_piece           : Run optional Time::Piece benchmark (see benchmark details).
 --bio_codons           : Run optional BioPerl Codons benchmark (does not scale well).
 --sleep <i>            : Sleep for <i> secs after each benchmark.
 --duration <i>, -d <i> : Minimum duration in seconds for suite run.
 --setup                : Download the GenBank data to enable the BioPerl tests.
 --datapath <path>      : Override the path where the expected benchmark data is found.
 --ver <num>            : Skip benchmarks added after the specified version.
 --help          -h     : Show basic help and exit.

The default run (no options) will run all the benchmarks both single-threaded and
multi-threaded (using all detected CPU cores/hyper-threads) and show you scores and
multi vs single threaded scalability.

=cut

use strict;
use warnings;

use lib 'lib';

use Digest;
use Benchmark::DKbench;
use Benchmark::DKbench::Setup;
use File::Spec::Functions;
use FindBin;
use Getopt::Long;
use Pod::Usage;

my %opt = ();
GetOptions (
    \%opt,
    'skip_bio',
    'skip_prove',
    'time_piece',
    'bio_codons',
    'quick|q',
    'time|t',
    'iter|i=i',
    'multi|m',
    'threads|j=i',
    'max_threads=i',
    'include=s',
    'exclude=s',
    'scale|s=i',
    'no_mce|n',
    'sleep=i',
    'stdev',
    'ver=s',
    'setup',
    'datapath=s',
    'duration|d=i',