NAME

Bencher::Scenario::Scalar::Util::Numeric - Benchmark Scalar::Util::Numeric vs Scalar::Util::Numeric::PP

VERSION

This document describes version 0.021 of Bencher::Scenario::Scalar::Util::Numeric (from Perl distribution Bencher-Scenario-Scalar-Util-Numeric), released on 2023-01-17.

SYNOPSIS

To run benchmark with default option:

 % bencher -m Scalar::Util::Numeric

To run module startup overhead benchmark:

 % bencher --module-startup -m Scalar::Util::Numeric

For more options (dump scenario, list/include/exclude/add participants, list/include/exclude/add datasets, etc), see bencher or run bencher --help.

DESCRIPTION

Packaging a benchmark script as a Bencher scenario makes it convenient to include/exclude/add participants/datasets (either via CLI or Perl code), send the result to a central repository, among others . See Bencher and bencher (CLI) for more details.

BENCHMARKED MODULES

Version numbers shown below are the versions used when running the sample benchmark.

Scalar::Util::Numeric::PP 0.04

Scalar::Util::Numeric 0.40

BENCHMARK PARTICIPANTS

isint-int-pp (perl_code) [pp, func:isint]

Function call template:
```
 Scalar::Util::Numeric::PP::isint(1)
```
isint-str-pp (perl_code) [pp, func:isint]

Function call template:
```
 Scalar::Util::Numeric::PP::isint('a')
```
isint-float-pp (perl_code) [pp, func:isint]

Function call template:
```
 Scalar::Util::Numeric::PP::isint(1.23)
```
isfloat-int-pp (perl_code) [pp, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::PP::isfloat(1)
```
isfloat-str-pp (perl_code) [pp, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::PP::isfloat('a')
```
isfloat-float-pp (perl_code) [pp, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::PP::isfloat(1.23)
```
isnum-int-pp (perl_code) [pp, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::PP::isnum(1)
```
isnum-str-pp (perl_code) [pp, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::PP::isnum('a')
```
isnum-float-pp (perl_code) [pp, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::PP::isnum(1.23)
```
isint-int-xs (perl_code) [xs, func:isint]

Function call template:
```
 Scalar::Util::Numeric::isint(1)
```
isint-str-xs (perl_code) [xs, func:isint]

Function call template:
```
 Scalar::Util::Numeric::isint('a')
```
isint-float-xs (perl_code) [xs, func:isint]

Function call template:
```
 Scalar::Util::Numeric::isint(1.23)
```
isfloat-int-xs (perl_code) [xs, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::isfloat(1)
```
isfloat-str-xs (perl_code) [xs, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::isfloat('a')
```
isfloat-float-xs (perl_code) [xs, func:isfloat]

Function call template:
```
 Scalar::Util::Numeric::isfloat(1.23)
```
isnum-int-xs (perl_code) [xs, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::isnum(1)
```
isnum-str-xs (perl_code) [xs, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::isnum('a')
```
isnum-float-xs (perl_code) [xs, func:isnum]

Function call template:
```
 Scalar::Util::Numeric::isnum(1.23)
```

SAMPLE BENCHMARK RESULTS

Run on: perl: v5.34.0, CPU: Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz (2 cores), OS: GNU/Linux Ubuntu version 20.04, OS kernel: Linux version 5.4.0-91-generic.

Benchmark with default options (bencher -m Scalar::Util::Numeric):

 #table1#
 +------------------+------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
 | participant      | p_tags           | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
 +------------------+------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
 | isnum-float-pp   | pp, func:isnum   |    490000 |    2      |                 0.00% |              4111.51% | 3.3e-09 |      20 |
 | isnum-str-pp     | pp, func:isnum   |    615800 |    1.624  |                25.70% |              3250.31% | 2.2e-11 |      20 |
 | isfloat-int-pp   | pp, func:isfloat |    860000 |    1.2    |                75.96% |              2293.38% | 1.6e-09 |      22 |
 | isfloat-float-pp | pp, func:isfloat |   1030000 |    0.971  |               110.29% |              1902.76% | 3.9e-10 |      23 |
 | isfloat-str-pp   | pp, func:isfloat |   1087000 |    0.9202 |               121.86% |              1798.31% | 2.2e-11 |      20 |
 | isint-float-pp   | pp, func:isint   |   1297000 |    0.7712 |               164.70% |              1491.08% | 4.6e-11 |      20 |
 | isnum-int-pp     | pp, func:isnum   |   1577000 |    0.6342 |               221.91% |              1208.27% | 2.3e-11 |      20 |
 | isint-int-pp     | pp, func:isint   |   2200000 |    0.45   |               352.58% |               830.55% | 8.3e-10 |      20 |
 | isint-float-xs   | xs, func:isint   |   2734000 |    0.3658 |               458.12% |               654.58% | 2.2e-11 |      20 |
 | isnum-float-xs   | xs, func:isnum   |   2735000 |    0.3656 |               458.41% |               654.20% | 2.1e-11 |      20 |
 | isfloat-float-xs | xs, func:isfloat |   2738000 |    0.3653 |               458.86% |               653.59% | 2.9e-11 |      20 |
 | isint-str-pp     | pp, func:isint   |   2980000 |    0.336  |               508.04% |               592.64% | 1.1e-10 |      20 |
 | isint-str-xs     | xs, func:isint   |  17000000 |    0.059  |              3383.67% |                20.89% | 2.1e-10 |      20 |
 | isnum-str-xs     | xs, func:isnum   |  18000000 |    0.057  |              3491.02% |                17.28% | 2.1e-10 |      20 |
 | isfloat-str-xs   | xs, func:isfloat |  18000000 |    0.054  |              3667.33% |                11.79% | 1.2e-10 |      20 |
 | isnum-int-xs     | xs, func:isnum   |  19000000 |    0.052  |              3805.01% |                 7.85% | 2.1e-10 |      20 |
 | isfloat-int-xs   | xs, func:isfloat |  19000000 |    0.052  |              3845.40% |                 6.74% | 2.1e-10 |      20 |
 | isint-int-xs     | xs, func:isint   |  21000000 |    0.048  |              4111.51% |                 0.00% | 3.4e-10 |      20 |
 +------------------+------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

Formatted as Benchmark.pm result:

                            Rate  i pp, func:isnum  i pp, func:isnum  i pp, func:isfloat  i pp, func:isfloat  i pp, func:isfloat  i pp, func:isint  i pp, func:isnum  i pp, func:isint  i xs, func:isint  i xs, func:isnum  i xs, func:isfloat  i pp, func:isint  i xs, func:isint  i xs, func:isnum  i xs, func:isfloat  i xs, func:isnum  i xs, func:isfloat  i xs, func:isint 
  i pp, func:isnum      490000/s                --              -18%                -40%                -51%                -53%              -61%              -68%              -77%              -81%              -81%                -81%              -83%              -97%              -97%                -97%              -97%                -97%              -97% 
  i pp, func:isnum      615800/s               23%                --                -26%                -40%                -43%              -52%              -60%              -72%              -77%              -77%                -77%              -79%              -96%              -96%                -96%              -96%                -96%              -97% 
  i pp, func:isfloat    860000/s               66%               35%                  --                -19%                -23%              -35%              -47%              -62%              -69%              -69%                -69%              -72%              -95%              -95%                -95%              -95%                -95%              -96% 
  i pp, func:isfloat   1030000/s              105%               67%                 23%                  --                 -5%              -20%              -34%              -53%              -62%              -62%                -62%              -65%              -93%              -94%                -94%              -94%                -94%              -95% 
  i pp, func:isfloat   1087000/s              117%               76%                 30%                  5%                  --              -16%              -31%              -51%              -60%              -60%                -60%              -63%              -93%              -93%                -94%              -94%                -94%              -94% 
  i pp, func:isint     1297000/s              159%              110%                 55%                 25%                 19%                --              -17%              -41%              -52%              -52%                -52%              -56%              -92%              -92%                -92%              -93%                -93%              -93% 
  i pp, func:isnum     1577000/s              215%              156%                 89%                 53%                 45%               21%                --              -29%              -42%              -42%                -42%              -47%              -90%              -91%                -91%              -91%                -91%              -92% 
  i pp, func:isint     2200000/s              344%              260%                166%                115%                104%               71%               40%                --              -18%              -18%                -18%              -25%              -86%              -87%                -88%              -88%                -88%              -89% 
  i xs, func:isint     2734000/s              446%              343%                228%                165%                151%              110%               73%               23%                --                0%                  0%               -8%              -83%              -84%                -85%              -85%                -85%              -86% 
  i xs, func:isnum     2735000/s              447%              344%                228%                165%                151%              110%               73%               23%                0%                --                  0%               -8%              -83%              -84%                -85%              -85%                -85%              -86% 
  i xs, func:isfloat   2738000/s              447%              344%                228%                165%                151%              111%               73%               23%                0%                0%                  --               -8%              -83%              -84%                -85%              -85%                -85%              -86% 
  i pp, func:isint     2980000/s              495%              383%                257%                188%                173%              129%               88%               33%                8%                8%                  8%                --              -82%              -83%                -83%              -84%                -84%              -85% 
  i xs, func:isint    17000000/s             3289%             2652%               1933%               1545%               1459%             1207%              974%              662%              520%              519%                519%              469%                --               -3%                 -8%              -11%                -11%              -18% 
  i xs, func:isnum    18000000/s             3408%             2749%               2005%               1603%               1514%             1252%             1012%              689%              541%              541%                540%              489%                3%                --                 -5%               -8%                 -8%              -15% 
  i xs, func:isfloat  18000000/s             3603%             2907%               2122%               1698%               1604%             1328%             1074%              733%              577%              577%                576%              522%                9%                5%                  --               -3%                 -3%              -11% 
  i xs, func:isnum    19000000/s             3746%             3023%               2207%               1767%               1669%             1383%             1119%              765%              603%              603%                602%              546%               13%                9%                  3%                --                  0%               -7% 
  i xs, func:isfloat  19000000/s             3746%             3023%               2207%               1767%               1669%             1383%             1119%              765%              603%              603%                602%              546%               13%                9%                  3%                0%                  --               -7% 
  i xs, func:isint    21000000/s             4066%             3283%               2400%               1922%               1817%             1506%             1221%              837%              662%              661%                661%              600%               22%               18%                 12%                8%                  8%                -- 
 
 Legends:
   i pp, func:isfloat: p_tags=pp, func:isfloat participant=isfloat-str-pp
   i pp, func:isint: p_tags=pp, func:isint participant=isint-str-pp
   i pp, func:isnum: p_tags=pp, func:isnum participant=isnum-int-pp
   i xs, func:isfloat: p_tags=xs, func:isfloat participant=isfloat-int-xs
   i xs, func:isint: p_tags=xs, func:isint participant=isint-int-xs
   i xs, func:isnum: p_tags=xs, func:isnum participant=isnum-int-xs

Benchmark module startup overhead (bencher -m Scalar::Util::Numeric --module-startup):

 #table2#
 +---------------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+
 | participant               | time (ms) | mod_overhead_time | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
 +---------------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+
 | Scalar::Util::Numeric     |      11   |               4.4 |                 0.00% |                63.80% | 6.1e-05 |      21 |
 | Scalar::Util::Numeric::PP |       9.8 |               3.2 |                11.43% |                47.01% | 2.9e-05 |      20 |
 | perl -e1 (baseline)       |       6.6 |               0   |                63.80% |                 0.00% | 3.6e-05 |      21 |
 +---------------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+

Formatted as Benchmark.pm result:

                          Rate  SU:N  SUN:P  perl -e1 (baseline) 
  SU:N                  90.9/s    --   -10%                 -40% 
  SUN:P                102.0/s   12%     --                 -32% 
  perl -e1 (baseline)  151.5/s   66%    48%                   -- 
 
 Legends:
   SU:N: mod_overhead_time=4.4 participant=Scalar::Util::Numeric
   SUN:P: mod_overhead_time=3.2 participant=Scalar::Util::Numeric::PP
   perl -e1 (baseline): mod_overhead_time=0 participant=perl -e1 (baseline)

To display as an interactive HTML table on a browser, you can add option --format html+datatables.

HOMEPAGE

Please visit the project's homepage at https://metacpan.org/release/Bencher-Scenario-Scalar-Util-Numeric.

SOURCE

Source repository is at https://github.com/perlancar/perl-Bencher-Scenario-Scalar-Util-Numeric.

AUTHOR

perlancar <perlancar@cpan.org>

CONTRIBUTING

To contribute, you can send patches by email/via RT, or send pull requests on GitHub.

Most of the time, you don't need to build the distribution yourself. You can simply modify the code, then test via:

 % prove -l

If you want to build the distribution (e.g. to try to install it locally on your system), you can install Dist::Zilla, Dist::Zilla::PluginBundle::Author::PERLANCAR, Pod::Weaver::PluginBundle::Author::PERLANCAR, and sometimes one or two other Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps required beyond that are considered a bug and can be reported to me.

COPYRIGHT AND LICENSE

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

BUGS

Please report any bugs or feature requests on the bugtracker website https://rt.cpan.org/Public/Dist/Display.html?Name=Bencher-Scenario-Scalar-Util-Numeric

When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature.

To install Bencher::Scenario::Scalar::Util::Numeric, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Bencher::Scenario::Scalar::Util::Numeric

CPAN shell

perl -MCPAN -e shell
install Bencher::Scenario::Scalar::Util::Numeric

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)