NAME

Bencher::Scenario::SetOperationModules - Benchmark Perl set operation (union, intersection, diff, symmetric diff) modules

VERSION

This document describes version 0.130 of Bencher::Scenario::SetOperationModules (from Perl distribution Bencher-Scenario-SetOperationModules), released on 2021-05-15.

SYNOPSIS

To run benchmark with default option:

% bencher -m SetOperationModules

To run module startup overhead benchmark:

% bencher --module-startup -m SetOperationModules

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.

Array::AsObject 1.02

Array::Set 0.062

Array::Set::Naive 0.001

Array::Utils 0.5

List::Collection 0.0.4

List::MoreUtils 0.428

List::MoreUtils::PP 0.428

Set::Array 0.30

Set::Object 1.40

Set::Scalar 1.29

Set::Tiny 0.04

BENCHMARK PARTICIPANTS

Array::Utils::unique (perl_code) [op:union]

Code template:
```
&Array::Utils::unique(<set1>, <set2>)
```

Set::Scalar::union (perl_code) [op:union]

Code template:

my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->union($s2)

List::MoreUtils::PP::uniq (perl_code) [op:union]

Function call template:
```
List::MoreUtils::PP::uniq(@{<set1>}, @{<set2>})
```
List::MoreUtils::XS::uniq (perl_code) [op:union]

Function call template:
```
List::MoreUtils::uniq(@{<set1>}, @{<set2>})
```
Array::Set::set_union (perl_code) [op:union]

Function call template:
```
Array::Set::set_union(<set1>, <set2>)
```
Array::Set::Naive::set_union (perl_code) [op:union]

Function call template:
```
Array::Set::Naive::set_union(<set1>, <set2>)
```

Set::Array::union (perl_code) [op:union]

Code template:

my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->union($s2)

Array::AsObject::union (perl_code) [op:union]

Code template:

my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->union($s2, 1)

Set::Object::union (perl_code) [op:union]

Code template:

my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->union($s2)

Set::Tiny::union (perl_code) [op:union]

Code template:

my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->union($s2)

List::Collection::union (perl_code) [op:union]

Code template:
```
[List::Collection::union(<set1>, <set2>)]
```
Array::Utils::array_diff (perl_code) [op:symdiff]

Code template:
```
&Array::Utils::array_diff(<set1>, <set2>)
```

Set::Scalar::symmetric_difference (perl_code) [op:symdiff]

Code template:

my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->symmetric_difference($s2)

List::MoreUtils::PP::singleton (perl_code) [op:symdiff]

Function call template:
```
List::MoreUtils::PP::singleton(@{<set1>}, @{<set2>})
```
List::MoreUtils::XS::singleton (perl_code) [op:symdiff]

Function call template:
```
List::MoreUtils::singleton(@{<set1>}, @{<set2>})
```
Array::Set::set_symdiff (perl_code) [op:symdiff]

Function call template:
```
Array::Set::set_symdiff(<set1>, <set2>)
```
Array::Set::Naive::set_symdiff (perl_code) [op:symdiff]

Function call template:
```
Array::Set::Naive::set_symdiff(<set1>, <set2>)
```

Set::Array::symmetric_difference (perl_code) [op:symdiff]

Code template:

my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->symmetric_difference($s2)

Array::AsObject::symmetric_difference (perl_code) [op:symdiff]

Code template:

my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->symmetric_difference($s2)

Set::Object::symmetric_difference (perl_code) [op:symdiff]

Code template:

my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->symmetric_difference($s2)

Set::Tiny::symmetric_difference (perl_code) [op:symdiff]

Code template:

my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->symmetric_difference($s2)

List::Collection::complement (perl_code) [op:symdiff]

Code template:
```
[List::Collection::complement(<set1>, <set2>)]
```
Array::Utils::array_minus (perl_code) [op:diff]

Code template:
```
&Array::Utils::array_minus(<set1>, <set2>)
```

Set::Scalar::difference (perl_code) [op:diff]

Code template:

my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->difference($s2)

Array::Set::set_diff (perl_code) [op:diff]

Function call template:
```
Array::Set::set_diff(<set1>, <set2>)
```
Array::Set::Naive::set_diff (perl_code) [op:diff]

Function call template:
```
Array::Set::Naive::set_diff(<set1>, <set2>)
```

Set::Array::difference (perl_code) [op:diff]

Code template:

my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->difference($s2)

Array::AsObject::difference (perl_code) [op:diff]

Code template:

my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->difference($s2)

Set::Object::difference (perl_code) [op:diff]

Code template:

my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->difference($s2)

Set::Tiny::difference (perl_code) [op:diff]

Code template:

my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->difference($s2)

List::Collection::subtract (perl_code) [op:diff]

Code template:
```
[List::Collection::subtract(<set1>, <set2>)]
```
Array::Utils::intersect (perl_code) [op:intersect]

Code template:
```
&Array::Utils::intersect(<set1>, <set2>)
```

Set::Scalar::intersection (perl_code) [op:intersect]

Code template:

my $s1 = Set::Scalar->new(@{<set1>}); my $s2 = Set::Scalar->new(@{<set2>}); $s1->intersection($s2)

Array::Set::set_intersect (perl_code) [op:intersect]

Function call template:
```
Array::Set::set_intersect(<set1>, <set2>)
```
Array::Set::Naive::set_intersect (perl_code) [op:intersect]

Function call template:
```
Array::Set::Naive::set_intersect(<set1>, <set2>)
```

Set::Array::intersection (perl_code) [op:intersect]

Code template:

my $s1 = Set::Array->new(@{<set1>}); my $s2 = Set::Array->new(@{<set2>}); $s1->intersection($s2)

Array::AsObject::intersection (perl_code) [op:intersect]

Code template:

my $s1 = Array::AsObject->new(@{<set1>}); my $s2 = Array::AsObject->new(@{<set2>}); $s1->intersection($s2, 1)

Set::Object::intersection (perl_code) [op:intersect]

Code template:

my $s1 = Set::Object->new(@{<set1>}); my $s2 = Set::Object->new(@{<set2>}); $s1->intersection($s2)

Set::Tiny::intersection (perl_code) [op:intersect]

Code template:

my $s1 = Set::Tiny->new(@{<set1>}); my $s2 = Set::Tiny->new(@{<set2>}); $s1->intersection($s2)

List::Collection::intersect (perl_code) [op:intersect]

Code template:
```
[List::Collection::intersect(<set1>, <set2>)]
```

BENCHMARK DATASETS

num10
num100
num1000 (not included by default)

SAMPLE BENCHMARK RESULTS

Run on: perl: v5.30.2, CPU: Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz (4 cores), OS: GNU/Linux LinuxMint version 19, OS kernel: Linux version 5.3.0-68-generic.

Benchmark with default options (bencher -m SetOperationModules):

#table1#
{dataset=>"num10",p_tags=>"op:diff"}
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                 | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Set::Scalar::difference     |     12000 |  81       |                 0.00% |              2147.13% |   2e-07 |      23 |
| Array::AsObject::difference |     26000 |  39       |               107.15% |               984.78% |   4e-08 |      20 |
| Set::Array::difference      |     70000 |  14.3     |               467.76% |               295.79% | 6.7e-09 |      20 |
| Set::Object::difference     |    120000 |   8.3     |               880.78% |               129.12% | 1.3e-08 |      20 |
| Array::Set::Naive::set_diff |    123482 |   8.09832 |               902.09% |               124.24% | 5.7e-12 |      25 |
| Set::Tiny::difference       |    150000 |   6.8     |              1100.16% |                87.24% | 1.3e-08 |      20 |
| List::Collection::subtract  |    188000 |   5.33    |              1423.25% |                47.52% | 1.7e-09 |      20 |
| Array::Set::set_diff        |    240000 |   4.2     |              1831.85% |                16.32% |   5e-09 |      20 |
| Array::Utils::array_minus   |    276900 |   3.61141 |              2147.13% |                 0.00% |   0     |      20 |
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table2#
{dataset=>"num100",p_tags=>"op:diff"}
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                 | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Array::AsObject::difference |       480 |    2.1    |                 0.00% |              6402.49% | 4.1e-06 |      20 |
| Set::Scalar::difference     |      2200 |    0.46   |               356.06% |              1325.78% | 6.9e-07 |      20 |
| Array::Set::Naive::set_diff |      5400 |    0.19   |              1028.66% |               476.12% | 2.1e-07 |      21 |
| Set::Array::difference      |     13000 |    0.074  |              2716.03% |               130.91% | 1.3e-07 |      22 |
| Set::Object::difference     |     15000 |    0.065  |              3111.12% |               102.50% | 9.9e-08 |      23 |
| Set::Tiny::difference       |     17000 |    0.059  |              3459.65% |                82.67% | 1.3e-07 |      20 |
| Array::Set::set_diff        |     30000 |    0.033  |              6194.58% |                 3.30% |   5e-08 |      23 |
| List::Collection::subtract  |     30700 |    0.0326 |              6307.72% |                 1.48% | 1.2e-08 |      23 |
| Array::Utils::array_minus   |     31100 |    0.0321 |              6402.49% |                 0.00% | 1.1e-08 |      29 |
+-----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table3#
{dataset=>"num10",p_tags=>"op:intersect"}
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                      | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Set::Scalar::intersection        |   12000   |  86       |                 0.00% |              2247.59% |   1e-07 |      21 |
| Array::AsObject::intersection    |   12000   |  82       |                 4.69% |              2142.42% | 1.1e-07 |      20 |
| List::Collection::intersect      |   19000   |  53       |                61.78% |              1351.06% |   1e-07 |      22 |
| Set::Array::intersection         |   32000   |  32       |               170.88% |               766.64% | 5.1e-08 |      22 |
| Set::Object::intersection        |   98244.7 |  10.1787  |               740.40% |               179.34% | 5.8e-12 |      20 |
| Array::Set::Naive::set_intersect |  103828   |   9.63133 |               788.16% |               164.32% | 5.8e-12 |      22 |
| Set::Tiny::intersection          |  160000   |   6.2     |              1270.32% |                71.32% | 8.1e-09 |      21 |
| Array::Set::set_intersect        |  189000   |   5.29    |              1516.38% |                45.24% | 1.6e-09 |      21 |
| Array::Utils::intersect          |  274438   |   3.64381 |              2247.59% |                 0.00% |   0     |      20 |
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table4#
{dataset=>"num100",p_tags=>"op:intersect"}
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                      | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Array::AsObject::intersection    |     240   | 4.3       |                 0.00% |             13169.36% | 5.3e-06 |      21 |
| Set::Array::intersection         |     486   | 2.06      |               106.40% |              6328.92% | 1.8e-06 |      20 |
| List::Collection::intersect      |    1370   | 0.73      |               482.00% |              2179.97% | 6.9e-07 |      20 |
| Set::Scalar::intersection        |    2000   | 0.5       |               742.88% |              1474.29% | 8.3e-07 |      21 |
| Array::Set::Naive::set_intersect |    4900   | 0.21      |              1964.66% |               542.69% | 2.1e-07 |      21 |
| Set::Object::intersection        |   11000   | 0.089     |              4695.13% |               176.73% | 1.1e-07 |      20 |
| Set::Tiny::intersection          |   18000   | 0.056     |              7446.19% |                75.84% | 1.1e-07 |      20 |
| Array::Set::set_intersect        |   22500   | 0.0444    |              9473.74% |                38.60% | 1.2e-08 |      23 |
| Array::Utils::intersect          |   31216.5 | 0.0320344 |             13169.36% |                 0.00% |   5e-12 |      21 |
+----------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table5#
{dataset=>"num10",p_tags=>"op:symdiff"}
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                           | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Array::AsObject::symmetric_difference |      5500 | 180       |                 0.00% |              7583.47% | 2.7e-07 |      20 |
| List::Collection::complement          |      8400 | 120       |                53.43% |              4907.67% | 6.4e-07 |      20 |
| Set::Scalar::symmetric_difference     |     19000 |  53       |               245.04% |              2126.86% |   8e-08 |      20 |
| Array::Set::Naive::set_symdiff        |     35357 |  28.283   |               545.81% |              1089.74% | 4.6e-11 |      23 |
| Set::Object::symmetric_difference     |     67000 |  15       |              1121.71% |               528.91% | 2.7e-08 |      20 |
| Set::Array::symmetric_difference      |     71200 |  14       |              1200.88% |               490.63% | 6.5e-09 |      21 |
| Set::Tiny::symmetric_difference       |    130000 |   7.4     |              2357.32% |               212.68% | 1.3e-08 |      20 |
| Array::Set::set_symdiff               |    170000 |   5.8     |              3071.71% |               142.25% | 6.7e-09 |      20 |
| Array::Utils::array_diff              |    220000 |   4.6     |              3864.59% |                93.80% | 6.7e-09 |      20 |
| List::MoreUtils::PP::singleton        |    242000 |   4.14    |              4312.27% |                74.14% | 1.4e-09 |      27 |
| List::MoreUtils::XS::singleton        |    420653 |   2.37726 |              7583.47% |                 0.00% |   0     |      20 |
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table6#
{dataset=>"num100",p_tags=>"op:symdiff"}
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                           | rate (/s) | time (ms) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Array::AsObject::symmetric_difference |     116   | 8.62      |                 0.00% |             43587.49% | 1.2e-06 |      20 |
| List::Collection::complement          |     550   | 1.8       |               371.84% |              9158.92% | 2.7e-06 |      20 |
| Array::Set::Naive::set_symdiff        |    2020   | 0.495     |              1643.33% |              2405.98% | 4.8e-07 |      20 |
| Set::Scalar::symmetric_difference     |    2900   | 0.34      |              2410.38% |              1640.27% | 4.2e-07 |      21 |
| Set::Object::symmetric_difference     |   10000   | 0.1       |              8492.96% |               408.41% | 1.3e-07 |      20 |
| Set::Array::symmetric_difference      |   13000   | 0.076     |             11297.33% |               283.31% | 9.9e-08 |      23 |
| Set::Tiny::symmetric_difference       |   15000   | 0.065     |             13191.71% |               228.68% |   1e-07 |      21 |
| Array::Set::set_symdiff               |   21600   | 0.0462    |             18545.58% |               134.30% | 1.3e-08 |      20 |
| List::MoreUtils::PP::singleton        |   28000   | 0.036     |             23741.01% |                83.25% |   5e-08 |      23 |
| Array::Utils::array_diff              |   27797.2 | 0.0359748 |             23864.84% |                82.30% | 2.3e-11 |      20 |
| List::MoreUtils::XS::singleton        |   51000   | 0.02      |             43587.49% |                 0.00% |   2e-08 |      20 |
+---------------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table7#
{dataset=>"num10",p_tags=>"op:union"}
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                  | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| Set::Scalar::union           |   12000   |  84       |                 0.00% |              7441.85% | 1.1e-07 |      20 |
| List::Collection::union      |   17000   |  59       |                42.10% |              5207.39% | 4.4e-07 |      21 |
| Array::Set::Naive::set_union |   67752.2 |  14.7597  |               468.02% |              1227.75% | 5.8e-12 |      23 |
| Array::AsObject::union       |   80800   |  12.4     |               577.60% |              1013.03% | 3.3e-09 |      21 |
| Set::Array::union            |  100000   |   9.7     |               762.18% |               774.74% | 1.3e-08 |      21 |
| Set::Object::union           |  116381   |   8.5925  |               875.70% |               672.97% |   0     |      20 |
| Set::Tiny::union             |  150000   |   6.6     |              1175.41% |               491.33% | 1.3e-08 |      20 |
| Array::Set::set_union        |  182000   |   5.48    |              1429.24% |               393.18% | 1.7e-09 |      20 |
| List::MoreUtils::PP::uniq    |  318229   |   3.14239 |              2567.95% |               182.68% |   0     |      20 |
| List::MoreUtils::XS::uniq    |  515000   |   1.94    |              4218.96% |                74.62% | 8.3e-10 |      20 |
| Array::Utils::unique         |  900000   |   1.11    |              7441.85% |                 0.00% | 4.1e-10 |      21 |
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

#table8#
{dataset=>"num100",p_tags=>"op:union"}
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant                  | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors | samples |
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| List::Collection::union      |     920   | 1100      |                 0.00% |             28313.54% | 1.3e-06 |      21 |
| Set::Scalar::union           |    2070   |  484      |               124.70% |             12545.09% | 4.8e-07 |      20 |
| Array::Set::Naive::set_union |    2900   |  350      |               210.18% |              9060.44% | 4.3e-07 |      20 |
| Array::AsObject::union       |   12000   |   87      |              1153.76% |              2166.27% | 2.1e-07 |      20 |
| Set::Object::union           |   14000   |   72      |              1418.92% |              1770.64% |   1e-07 |      21 |
| Set::Tiny::union             |   17000   |   60      |              1711.03% |              1468.92% | 9.2e-08 |      27 |
| Set::Array::union            |   22000   |   46      |              2267.06% |              1100.37% | 5.2e-08 |      21 |
| Array::Set::set_union        |   21900   |   45.8    |              2276.42% |              1095.65% |   4e-08 |      20 |
| List::MoreUtils::PP::uniq    |   36848.1 |   27.1384 |              3906.17% |               609.24% |   0     |      20 |
| List::MoreUtils::XS::uniq    |   65000   |   15      |              6934.26% |               303.93% | 2.7e-08 |      20 |
| Array::Utils::unique         |  261000   |    3.83   |             28313.54% |                 0.00% | 1.7e-09 |      20 |
+------------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+

Benchmark module startup overhead (bencher -m SetOperationModules --module-startup):

#table9#
+---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+
| participant         | time (ms) | mod_overhead_time | pct_faster_vs_slowest | pct_slower_vs_fastest |  errors   | samples |
+---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+
| Array::AsObject     |      20   |              15   |                 0.00% |               251.58% |   0.00018 |      20 |
| Set::Array          |      20   |              15   |                 6.54% |               230.00% |   0.0002  |      21 |
| List::Collection    |      16   |              11   |                12.78% |               211.73% |   0.00011 |      20 |
| Set::Object         |      10   |               5   |                28.02% |               174.64% |   0.00014 |      20 |
| Set::Scalar         |      13   |               8   |                42.28% |               147.11% | 3.4e-05   |      20 |
| List::MoreUtils     |      12   |               7   |                53.89% |               128.46% | 3.7e-05   |      20 |
| List::MoreUtils::PP |       9.1 |               4.1 |                96.61% |                78.82% | 3.2e-05   |      20 |
| Array::Set::Naive   |       9   |               4   |               109.72% |                67.64% |   0.00017 |      21 |
| Array::Set          |       8   |               3   |               121.13% |                59.00% |   0.00015 |      20 |
| Set::Tiny           |       7   |               2   |               150.59% |                40.30% |   0.00023 |      21 |
| Array::Utils        |       6   |               1   |               186.55% |                22.69% |   0.00024 |      20 |
| perl -e1 (baseline) |       5   |               0   |               251.58% |                 0.00% |   0.0001  |      20 |
+---------------------+-----------+-------------------+-----------------------+-----------------------+-----------+---------+

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-SetOperationModules.

SOURCE

Source repository is at https://github.com/perlancar/perl-Bencher-Scenario-SetOperationModules.

BUGS

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

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.

AUTHOR

perlancar <perlancar@cpan.org>

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.

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

cpanm

cpanm Bencher::Scenario::SetOperationModules

CPAN shell

perl -MCPAN -e shell
install Bencher::Scenario::SetOperationModules

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)

NAME

VERSION

SYNOPSIS

DESCRIPTION

BENCHMARKED MODULES

BENCHMARK PARTICIPANTS

BENCHMARK DATASETS

SAMPLE BENCHMARK RESULTS

HOMEPAGE

SOURCE

BUGS

SEE ALSO

AUTHOR

COPYRIGHT AND LICENSE

Module Install Instructions