t/perf/benchmarks

   1 #!perl
   2
   3 # This file specifies an array-of-hashes that define snippets of code that
   4 # can be run by various measurement and profiling tools.
   5 #
   6 # The basic idea is that any time you add an optimisation that is intended
   7 # to make a particular construct faster, then you should add that construct
   8 # to this file.
   9 #
  10 # Under the normal test suite, the test file benchmarks.t does a basic
  11 # compile and run of each of these snippets; not to test performance,
  12 # but just to ensure that the code doesn't have errors.
  13 #
  14 # Over time, it is intended that various measurement and profiling tools
  15 # will be written that can run selected (or all) snippets in various
  16 # environments. These will not be run as part of a normal test suite run.
  17 #
  18 # It is intended that the tests in this file will be lightweight; e.g.
  19 # a hash access, an empty function call, or a single regex match etc.
  20 #
  21 # This file is designed to be read in by 'do' (and in such a way that
  22 # multiple versions of this file from different releases can be read in
  23 # by a single process).
  24 #
  25 # The top-level array has name/hash pairs (we use an array rather than a
  26 # hash so that duplicate keys can be spotted) Each name is a token that
  27 # describes a particular test. Code will be compiled in the package named
  28 # after the token, so it should match /^(\w|::)+$/a. It is intended that
  29 # this can be used on the command line of tools to select particular
  30 # tests.
  31 # In addition, the package names are arranged into an informal hierarchy
  32 # whose top members are (this is subject to change):
  33 #
  34 #     call::     subroutine and method handling
  35 #     expr::     expressions: e.g. $x=1, $foo{bar}[0]
  36 #     func::     perl functions, e.g. func::sort::...
  37 #     loop::     structural code like for, while(), etc
  38 #     regex::    regular expressions
  39 #     string::   string handling
  40 #
  41 #
  42 # Each hash has three fields:
  43 #
  44 #   desc is a description of the test
  45 #   setup is a string containing setup code
  46 #   code  is a string containing the code to run in a loop
  47 #
  48 # So typically a benchmark tool might do something like
  49 #
  50 #   eval "package $token; $setup; for (1..1000000) { $code }"
  51 #
  52 # Currently the only tool that uses this file is Porting/bench.pl;
  53 # try C<perl Porting/bench.pl --help> for more info
  54 #
  55 # ------
  56 #
  57 # Note: for the cachegrind variant, an entry like
  58 #    'foo::bar' => {
  59 #     setup   => 'SETUP',
  60 #     code    => 'CODE',
  61 #   }
  62 # creates two temporary perl sources looking like:
  63 #
  64 #        package foo::bar;
  65 #        BEGIN { srand(0) }
  66 #        SETUP;
  67 #        for my $__loop__ (1..$ARGV[0]) {
  68 #            1;
  69 #        }
  70 #
  71 # and as above, but with the '1;' in the loop  body replaced with:
  72 #
  73 #            CODE;
  74 #
  75 # It then pipes each of the two sources into
  76 #
  77 #     PERL_HASH_SEED=0 valgrind [options] someperl [options] - N
  78 #
  79 # where N is set to 10 and then 20.
  80 #
  81 # It then uses the result of those four cachegrind runs to subtract out
  82 # the perl startup and loop overheads. So only what's in SETUP and CODE
  83 # can affect the benchmark, and if the loop happens to leave some state
  84 # changed (such as storing a value in a hash), then the final benchmark
  85 # timing is the result of running CODE with the hash entry populated
  86 # rather than empty.
  87
  88
  89 [
  90     'call::sub::empty' => {
  91         desc    => 'function call with no args or body',
  92         setup   => 'sub f { }',
  93         code    => 'f()',
  94     },
  95     'call::sub::amp_empty' => {
  96         desc    => '&foo function call with no args or body',
  97         setup   => 'sub f { }; @_ = ();',
  98         code    => '&f',
  99     },
 100     'call::sub::args3' => {
 101         desc    => 'function call with 3 local lexical vars',
 102         setup   => 'sub f { my ($a, $b, $c) = @_; 1 }',
 103         code    => 'f(1,2,3)',
 104     },
 105     'call::sub::args2_ret1' => {
 106         desc    => 'function call with 2 local lex vars and 1 return value',
 107         setup   => 'my $x; sub f { my ($a, $b) = @_; $a+$b }',
 108         code    => '$x = f(1,2)',
 109     },
 110     'call::sub::args2_ret1temp' => {
 111         desc    => 'function call with 2 local lex vars and 1 return TEMP value',
 112         setup   => 'my $x; sub f { my ($a, $b) = @_; \$a }',
 113         code    => '$x = f(1,2)',
 114     },
 115     'call::sub::args3_ret3' => {
 116         desc    => 'function call with 3 local lex vars and 3 return values',
 117         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; $a+$b, $c, 1 }',
 118         code    => '@a = f(1,2,3)',
 119     },
 120     'call::sub::args3_ret3str' => {
 121         desc    => 'function call with 3 local lex vars and 3 string return values',
 122         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; my @s = ("aa","bb","cc"); @s }',
 123         code    => '@a = f(1,2,3)',
 124     },
 125     'call::sub::args3_ret3temp' => {
 126         desc    => 'function call with 3 local lex vars and 3 TEMP return values',
 127         setup   => 'my @a; sub f { my ($a, $b, $c) = @_; 1..3 }',
 128         code    => '@a = f(1,2,3)',
 129     },
 130     'call::sub::recursive' => {
 131         desc    => 'basic recursive function call',
 132         setup   => 'my $x; sub f { my ($i) = @_; $i > 0 ? $i + f($i-1) : 0 }',
 133         code    => '$x = f(1)',
 134     },
 135
 136     'call::goto::empty' => {
 137         desc    => 'goto &funtion with no args or body',
 138         setup   => 'sub f { goto &g } sub g {}',
 139         code    => 'f()',
 140     },
 141     'call::goto::args3' => {
 142         desc    => 'goto &funtion with 3 local lexical vars',
 143         setup   => 'sub f { goto &g } sub g { my ($a, $b, $c) = @_ }',
 144         code    => 'f(1,2,3)',
 145     },
 146
 147
 148     'expr::array::lex_1const_0' => {
 149         desc    => 'lexical $array[0]',
 150         setup   => 'my @a = (1)',
 151         code    => '$a[0]',
 152     },
 153     'expr::array::lex_1const_m1' => {
 154         desc    => 'lexical $array[-1]',
 155         setup   => 'my @a = (1)',
 156         code    => '$a[-1]',
 157     },
 158     'expr::array::lex_2const' => {
 159         desc    => 'lexical $array[const][const]',
 160         setup   => 'my @a = ([1,2])',
 161         code    => '$a[0][1]',
 162     },
 163     'expr::array::lex_2var' => {
 164         desc    => 'lexical $array[$i1][$i2]',
 165         setup   => 'my ($i1,$i2) = (0,1); my @a = ([1,2])',
 166         code    => '$a[$i1][$i2]',
 167     },
 168     'expr::array::ref_lex_2var' => {
 169         desc    => 'lexical $arrayref->[$i1][$i2]',
 170         setup   => 'my ($i1,$i2) = (0,1); my $r = [[1,2]]',
 171         code    => '$r->[$i1][$i2]',
 172     },
 173     'expr::array::ref_lex_3const' => {
 174         desc    => 'lexical $arrayref->[const][const][const]',
 175         setup   => 'my $r = [[[1,2]]]',
 176         code    => '$r->[0][0][0]',
 177     },
 178     'expr::array::ref_expr_lex_3const' => {
 179         desc    => '(lexical expr)->[const][const][const]',
 180         setup   => 'my $r = [[[1,2]]]',
 181         code    => '($r||0)->[0][0][0]',
 182     },
 183
 184
 185     'expr::array::pkg_1const_0' => {
 186         desc    => 'package $array[0]',
 187         setup   => '@a = (1)',
 188         code    => '$a[0]',
 189     },
 190     'expr::array::pkg_1const_m1' => {
 191         desc    => 'package $array[-1]',
 192         setup   => '@a = (1)',
 193         code    => '$a[-1]',
 194     },
 195     'expr::array::pkg_2const' => {
 196         desc    => 'package $array[const][const]',
 197         setup   => '@a = ([1,2])',
 198         code    => '$a[0][1]',
 199     },
 200     'expr::array::pkg_2var' => {
 201         desc    => 'package $array[$i1][$i2]',
 202         setup   => '($i1,$i2) = (0,1); @a = ([1,2])',
 203         code    => '$a[$i1][$i2]',
 204     },
 205     'expr::array::ref_pkg_2var' => {
 206         desc    => 'package $arrayref->[$i1][$i2]',
 207         setup   => '($i1,$i2) = (0,1); $r = [[1,2]]',
 208         code    => '$r->[$i1][$i2]',
 209     },
 210     'expr::array::ref_pkg_3const' => {
 211         desc    => 'package $arrayref->[const][const][const]',
 212         setup   => '$r = [[[1,2]]]',
 213         code    => '$r->[0][0][0]',
 214     },
 215     'expr::array::ref_expr_pkg_3const' => {
 216         desc    => '(package expr)->[const][const][const]',
 217         setup   => '$r = [[[1,2]]]',
 218         code    => '($r||0)->[0][0][0]',
 219     },
 220
 221
 222     'expr::arrayhash::lex_3var' => {
 223         desc    => 'lexical $h{$k1}[$i]{$k2}',
 224         setup   => 'my ($i, $k1, $k2) = (0,"foo","bar");'
 225                     . 'my %h = (foo => [ { bar => 1 } ])',
 226         code    => '$h{$k1}[$i]{$k2}',
 227     },
 228     'expr::arrayhash::pkg_3var' => {
 229         desc    => 'package $h{$k1}[$i]{$k2}',
 230         setup   => '($i, $k1, $k2) = (0,"foo","bar");'
 231                     . '%h = (foo => [ { bar => 1 } ])',
 232         code    => '$h{$k1}[$i]{$k2}',
 233     },
 234
 235     'expr::hash::lex_1const' => {
 236         desc    => 'lexical $hash{const}',
 237         setup   => 'my %h = ("foo" => 1)',
 238         code    => '$h{foo}',
 239     },
 240     'expr::hash::lex_2const' => {
 241         desc    => 'lexical $hash{const}{const}',
 242         setup   => 'my %h = (foo => { bar => 1 })',
 243         code    => '$h{foo}{bar}',
 244     },
 245     'expr::hash::lex_2var' => {
 246         desc    => 'lexical $hash{$k1}{$k2}',
 247         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 })',
 248         code    => '$h{$k1}{$k2}',
 249     },
 250     'expr::hash::ref_lex_2var' => {
 251         desc    => 'lexical $hashref->{$k1}{$k2}',
 252         setup   => 'my ($k1,$k2) = qw(foo bar); my $r = {$k1 => { $k2 => 1 }}',
 253         code    => '$r->{$k1}{$k2}',
 254     },
 255     'expr::hash::ref_lex_3const' => {
 256         desc    => 'lexical $hashref->{const}{const}{const}',
 257         setup   => 'my $r = {foo => { bar => { baz => 1 }}}',
 258         code    => '$r->{foo}{bar}{baz}',
 259     },
 260     'expr::hash::ref_expr_lex_3const' => {
 261         desc    => '(lexical expr)->{const}{const}{const}',
 262         setup   => 'my $r = {foo => { bar => { baz => 1 }}}',
 263         code    => '($r||0)->{foo}{bar}{baz}',
 264     },
 265
 266     'expr::hash::pkg_1const' => {
 267         desc    => 'package $hash{const}',
 268         setup   => '%h = ("foo" => 1)',
 269         code    => '$h{foo}',
 270     },
 271     'expr::hash::pkg_2const' => {
 272         desc    => 'package $hash{const}{const}',
 273         setup   => '%h = (foo => { bar => 1 })',
 274         code    => '$h{foo}{bar}',
 275     },
 276     'expr::hash::pkg_2var' => {
 277         desc    => 'package $hash{$k1}{$k2}',
 278         setup   => '($k1,$k2) = qw(foo bar); %h = ($k1 => { $k2 => 1 })',
 279         code    => '$h{$k1}{$k2}',
 280     },
 281     'expr::hash::ref_pkg_2var' => {
 282         desc    => 'package $hashref->{$k1}{$k2}',
 283         setup   => '($k1,$k2) = qw(foo bar); $r = {$k1 => { $k2 => 1 }}',
 284         code    => '$r->{$k1}{$k2}',
 285     },
 286     'expr::hash::ref_pkg_3const' => {
 287         desc    => 'package $hashref->{const}{const}{const}',
 288         setup   => '$r = {foo => { bar => { baz => 1 }}}',
 289         code    => '$r->{foo}{bar}{baz}',
 290     },
 291     'expr::hash::ref_expr_pkg_3const' => {
 292         desc    => '(package expr)->{const}{const}{const}',
 293         setup   => '$r = {foo => { bar => { baz => 1 }}}',
 294         code    => '($r||0)->{foo}{bar}{baz}',
 295     },
 296
 297
 298     'expr::hash::exists_lex_2var' => {
 299         desc    => 'lexical exists $hash{$k1}{$k2}',
 300         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 });',
 301         code    => 'exists $h{$k1}{$k2}',
 302     },
 303
 304     'expr::hash::bool_empty' => {
 305         desc    => 'empty lexical hash in boolean context',
 306         setup   => 'my %h;',
 307         code    => '!%h',
 308     },
 309     'expr::hash::bool_full' => {
 310         desc    => 'non-empty lexical hash in boolean context',
 311         setup   => 'my %h = 1..10;',
 312         code    => '!%h',
 313     },
 314
 315
 316     (
 317         map {
 318             sprintf('expr::hash::notexists_lex_keylen%04d',$_) => {
 319                 desc    => 'exists on non-key of length '. $_,
 320                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key."x"} = 1;',
 321                 code    => 'exists $h{$key}',
 322             },
 323         } (
 324             1 .. 24,
 325             # 1,2,3,7,8,9,14,15,16,20,24,
 326             50,
 327             100,
 328             1000,
 329         )
 330     ),
 331     (
 332         map {
 333             sprintf('expr::hash::exists_lex_keylen%04d',$_) => {
 334                 desc    => 'exists on existing key of length '. $_,
 335                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key} = 1;',
 336                 code    => 'exists $h{$key}',
 337             },
 338         } (
 339             1 .. 24,
 340             # 1,2,3,7,8,9,14,15,16,20,24,
 341             50,
 342             100,
 343             1000,
 344         )
 345     ),
 346
 347     'expr::hash::delete_lex_2var' => {
 348         desc    => 'lexical delete $hash{$k1}{$k2}',
 349         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 });',
 350         code    => 'delete $h{$k1}{$k2}',
 351     },
 352
 353
 354     # list assign, OP_AASSIGN
 355
 356
 357     # (....) = ()
 358
 359     'expr::aassign::ma_empty' => {
 360         desc    => 'my array assigned empty',
 361         setup   => '',
 362         code    => 'my @a = ()',
 363     },
 364     'expr::aassign::lax_empty' => {
 365         desc    => 'non-empty lexical array assigned empty',
 366         setup   => 'my @a = 1..3;',
 367         code    => '@a = ()',
 368     },
 369     'expr::aassign::llax_empty' => {
 370         desc    => 'non-empty lexical var and array assigned empty',
 371         setup   => 'my ($x, @a) = 1..4;',
 372         code    => '($x, @a) = ()',
 373     },
 374     'expr::aassign::mh_empty' => {
 375         desc    => 'my hash assigned empty',
 376         setup   => '',
 377         code    => 'my %h = ()',
 378     },
 379     'expr::aassign::lhx_empty' => {
 380         desc    => 'non-empty lexical hash assigned empty',
 381         setup   => 'my %h = 1..4;',
 382         code    => '%h = ()',
 383     },
 384     'expr::aassign::llhx_empty' => {
 385         desc    => 'non-empty lexical var and hash assigned empty',
 386         setup   => 'my ($x, %h) = 1..5;',
 387         code    => '($x, %h) = ()',
 388     },
 389     'expr::aassign::3m_empty' => {
 390         desc    => 'three my vars assigned empty',
 391         setup   => '',
 392         code    => 'my ($x,$y,$z) = ()',
 393     },
 394     'expr::aassign::3l_empty' => {
 395         desc    => 'three lexical vars assigned empty',
 396         setup   => 'my ($x,$y,$z)',
 397         code    => '($x,$y,$z) = ()',
 398     },
 399     'expr::aassign::3lref_empty' => {
 400         desc    => 'three lexical ref vars assigned empty',
 401         setup   => 'my ($x,$y,$z); my $r = []; ',
 402         code    => '($x,$y,$z) = ($r,$r,$r); ($x,$y,$z) = ()',
 403     },
 404     'expr::aassign::pa_empty' => {
 405         desc    => 'package array assigned empty',
 406         setup   => '',
 407         code    => '@a = ()',
 408     },
 409     'expr::aassign::pax_empty' => {
 410         desc    => 'non-empty package array assigned empty',
 411         setup   => '@a = (1,2,3)',
 412         code    => '@a = ()',
 413     },
 414     'expr::aassign::3p_empty' => {
 415         desc    => 'three package vars assigned empty',
 416         setup   => '($x,$y,$z) = 1..3;',
 417         code    => '($x,$y,$z) = ()',
 418     },
 419
 420     # (....) = (1,2,3)
 421
 422     'expr::aassign::ma_3c' => {
 423         desc    => 'my array assigned 3 consts',
 424         setup   => '',
 425         code    => 'my @a = (1,2,3)',
 426     },
 427     'expr::aassign::lax_3c' => {
 428         desc    => 'non-empty lexical array assigned 3 consts',
 429         setup   => 'my @a = 1..3;',
 430         code    => '@a = (1,2,3)',
 431     },
 432     'expr::aassign::llax_3c' => {
 433         desc    => 'non-empty lexical var and array assigned 3 consts',
 434         setup   => 'my ($x, @a) = 1..4;',
 435         code    => '($x, @a) = (1,2,3)',
 436     },
 437     'expr::aassign::mh_4c' => {
 438         desc    => 'my hash assigned 4 consts',
 439         setup   => '',
 440         code    => 'my %h = qw(a 1 b 2)',
 441     },
 442     'expr::aassign::lhx_4c' => {
 443         desc    => 'non-empty lexical hash assigned 4 consts',
 444         setup   => 'my %h = qw(a 1 b 2);',
 445         code    => '%h = qw(c 3 d 4)',
 446     },
 447     'expr::aassign::llhx_5c' => {
 448         desc    => 'non-empty lexical var and array assigned 5 consts',
 449         setup   => 'my ($x, %h) = (1, qw(a 1 b 2));',
 450         code    => '($x, %h) = (10, qw(c 3 d 4))',
 451     },
 452     'expr::aassign::3m_3c' => {
 453         desc    => 'three my vars assigned 3 consts',
 454         setup   => '',
 455         code    => 'my ($x,$y,$z) = (1,2,3)',
 456     },
 457     'expr::aassign::3l_3c' => {
 458         desc    => 'three lexical vars assigned 3 consts',
 459         setup   => 'my ($x,$y,$z)',
 460         code    => '($x,$y,$z) = (1,2,3)',
 461     },
 462     'expr::aassign::pa_3c' => {
 463         desc    => 'package array assigned 3 consts',
 464         setup   => '',
 465         code    => '@a = (1,2,3)',
 466     },
 467     'expr::aassign::pax_3c' => {
 468         desc    => 'non-empty package array assigned 3 consts',
 469         setup   => '@a = (1,2,3)',
 470         code    => '@a = (1,2,3)',
 471     },
 472     'expr::aassign::3p_3c' => {
 473         desc    => 'three package vars assigned 3 consts',
 474         setup   => '($x,$y,$z) = 1..3;',
 475         code    => '($x,$y,$z) = (1,2,3)',
 476     },
 477
 478     # (....) = @lexical
 479
 480     'expr::aassign::ma_la' => {
 481         desc    => 'my array assigned lexical array',
 482         setup   => 'my @init = 1..3;',
 483         code    => 'my @a = @init',
 484     },
 485     'expr::aassign::lax_la' => {
 486         desc    => 'non-empty lexical array assigned lexical array',
 487         setup   => 'my @init = 1..3; my @a = 1..3;',
 488         code    => '@a = @init',
 489     },
 490     'expr::aassign::llax_la' => {
 491         desc    => 'non-empty lexical var and array assigned lexical array',
 492         setup   => 'my @init = 1..3; my ($x, @a) = 1..4;',
 493         code    => '($x, @a) = @init',
 494     },
 495     'expr::aassign::3m_la' => {
 496         desc    => 'three my vars assigned lexical array',
 497         setup   => 'my @init = 1..3;',
 498         code    => 'my ($x,$y,$z) = @init',
 499     },
 500     'expr::aassign::3l_la' => {
 501         desc    => 'three lexical vars assigned lexical array',
 502         setup   => 'my @init = 1..3; my ($x,$y,$z)',
 503         code    => '($x,$y,$z) = @init',
 504     },
 505     'expr::aassign::pa_la' => {
 506         desc    => 'package array assigned lexical array',
 507         setup   => 'my @init = 1..3;',
 508         code    => '@a = @init',
 509     },
 510     'expr::aassign::pax_la' => {
 511         desc    => 'non-empty package array assigned lexical array',
 512         setup   => 'my @init = 1..3; @a = @init',
 513         code    => '@a = @init',
 514     },
 515     'expr::aassign::3p_la' => {
 516         desc    => 'three package vars assigned lexical array',
 517         setup   => 'my @init = 1..3; ($x,$y,$z) = 1..3;',
 518         code    => '($x,$y,$z) = @init',
 519     },
 520
 521     # (....) = @package
 522
 523     'expr::aassign::ma_pa' => {
 524         desc    => 'my array assigned package array',
 525         setup   => '@init = 1..3;',
 526         code    => 'my @a = @init',
 527     },
 528     'expr::aassign::lax_pa' => {
 529         desc    => 'non-empty lexical array assigned package array',
 530         setup   => '@init = 1..3; my @a = 1..3;',
 531         code    => '@a = @init',
 532     },
 533     'expr::aassign::llax_pa' => {
 534         desc    => 'non-empty lexical var and array assigned package array',
 535         setup   => '@init = 1..3; my ($x, @a) = 1..4;',
 536         code    => '($x, @a) = @init',
 537     },
 538     'expr::aassign::3m_pa' => {
 539         desc    => 'three my vars assigned package array',
 540         setup   => '@init = 1..3;',
 541         code    => 'my ($x,$y,$z) = @init',
 542     },
 543     'expr::aassign::3l_pa' => {
 544         desc    => 'three lexical vars assigned package array',
 545         setup   => '@init = 1..3; my ($x,$y,$z)',
 546         code    => '($x,$y,$z) = @init',
 547     },
 548     'expr::aassign::pa_pa' => {
 549         desc    => 'package array assigned package array',
 550         setup   => '@init = 1..3;',
 551         code    => '@a = @init',
 552     },
 553     'expr::aassign::pax_pa' => {
 554         desc    => 'non-empty package array assigned package array',
 555         setup   => '@init = 1..3; @a = @init',
 556         code    => '@a = @init',
 557     },
 558     'expr::aassign::3p_pa' => {
 559         desc    => 'three package vars assigned package array',
 560         setup   => '@init = 1..3; ($x,$y,$z) = 1..3;',
 561         code    => '($x,$y,$z) = @init',
 562     },
 563
 564     # (....) = @_;
 565
 566     'expr::aassign::ma_defary' => {
 567         desc    => 'my array assigned @_',
 568         setup   => '@_ = 1..3;',
 569         code    => 'my @a = @_',
 570     },
 571     'expr::aassign::lax_defary' => {
 572         desc    => 'non-empty lexical array assigned @_',
 573         setup   => '@_ = 1..3; my @a = 1..3;',
 574         code    => '@a = @_',
 575     },
 576     'expr::aassign::llax_defary' => {
 577         desc    => 'non-empty lexical var and array assigned @_',
 578         setup   => '@_ = 1..3; my ($x, @a) = 1..4;',
 579         code    => '($x, @a) = @_',
 580     },
 581     'expr::aassign::3m_defary' => {
 582         desc    => 'three my vars assigned @_',
 583         setup   => '@_ = 1..3;',
 584         code    => 'my ($x,$y,$z) = @_',
 585     },
 586     'expr::aassign::3l_defary' => {
 587         desc    => 'three lexical vars assigned @_',
 588         setup   => '@_ = 1..3; my ($x,$y,$z)',
 589         code    => '($x,$y,$z) = @_',
 590     },
 591     'expr::aassign::pa_defary' => {
 592         desc    => 'package array assigned @_',
 593         setup   => '@_ = 1..3;',
 594         code    => '@a = @_',
 595     },
 596     'expr::aassign::pax_defary' => {
 597         desc    => 'non-empty package array assigned @_',
 598         setup   => '@_ = 1..3; @a = @_',
 599         code    => '@a = @_',
 600     },
 601     'expr::aassign::3p_defary' => {
 602         desc    => 'three package vars assigned @_',
 603         setup   => '@_ = 1..3; ($x,$y,$z) = 1..3;',
 604         code    => '($x,$y,$z) = @_',
 605     },
 606
 607
 608     # (....) = ($lex1,$lex2,$lex3);
 609
 610     'expr::aassign::ma_3l' => {
 611         desc    => 'my array assigned lexicals',
 612         setup   => 'my ($v1,$v2,$v3) = 1..3;',
 613         code    => 'my @a = ($v1,$v2,$v3)',
 614     },
 615     'expr::aassign::lax_3l' => {
 616         desc    => 'non-empty lexical array assigned lexicals',
 617         setup   => 'my ($v1,$v2,$v3) = 1..3; my @a = 1..3;',
 618         code    => '@a = ($v1,$v2,$v3)',
 619     },
 620     'expr::aassign::llax_3l' => {
 621         desc    => 'non-empty lexical var and array assigned lexicals',
 622         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
 623         code    => '($x, @a) = ($v1,$v2,$v3)',
 624     },
 625     'expr::aassign::3m_3l' => {
 626         desc    => 'three my vars assigned lexicals',
 627         setup   => 'my ($v1,$v2,$v3) = 1..3;',
 628         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
 629     },
 630     'expr::aassign::3l_3l' => {
 631         desc    => 'three lexical vars assigned lexicals',
 632         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
 633         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
 634     },
 635     'expr::aassign::pa_3l' => {
 636         desc    => 'package array assigned lexicals',
 637         setup   => 'my ($v1,$v2,$v3) = 1..3;',
 638         code    => '@a = ($v1,$v2,$v3)',
 639     },
 640     'expr::aassign::pax_3l' => {
 641         desc    => 'non-empty package array assigned lexicals',
 642         setup   => 'my ($v1,$v2,$v3) = 1..3; @a = @_',
 643         code    => '@a = ($v1,$v2,$v3)',
 644     },
 645     'expr::aassign::3p_3l' => {
 646         desc    => 'three package vars assigned lexicals',
 647         setup   => 'my ($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
 648         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
 649     },
 650
 651
 652     # (....) = ($pkg1,$pkg2,$pkg3);
 653
 654     'expr::aassign::ma_3p' => {
 655         desc    => 'my array assigned 3 package vars',
 656         setup   => '($v1,$v2,$v3) = 1..3;',
 657         code    => 'my @a = ($v1,$v2,$v3)',
 658     },
 659     'expr::aassign::lax_3p' => {
 660         desc    => 'non-empty lexical array assigned 3 package vars',
 661         setup   => '($v1,$v2,$v3) = 1..3; my @a = 1..3;',
 662         code    => '@a = ($v1,$v2,$v3)',
 663     },
 664     'expr::aassign::llax_3p' => {
 665         desc    => 'non-empty lexical var and array assigned 3 package vars',
 666         setup   => '($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
 667         code    => '($x, @a) = ($v1,$v2,$v3)',
 668     },
 669     'expr::aassign::3m_3p' => {
 670         desc    => 'three my vars assigned 3 package vars',
 671         setup   => '($v1,$v2,$v3) = 1..3;',
 672         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
 673     },
 674     'expr::aassign::3l_3p' => {
 675         desc    => 'three lexical vars assigned 3 package vars',
 676         setup   => '($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
 677         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
 678     },
 679     'expr::aassign::pa_3p' => {
 680         desc    => 'package array assigned 3 package vars',
 681         setup   => '($v1,$v2,$v3) = 1..3;',
 682         code    => '@a = ($v1,$v2,$v3)',
 683     },
 684     'expr::aassign::pax_3p' => {
 685         desc    => 'non-empty package array assigned 3 package vars',
 686         setup   => '($v1,$v2,$v3) = 1..3; @a = @_',
 687         code    => '@a = ($v1,$v2,$v3)',
 688     },
 689     'expr::aassign::3p_3p' => {
 690         desc    => 'three package vars assigned 3 package vars',
 691         setup   => '($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
 692         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
 693     },
 694
 695
 696     # (....) = (1,2,$shared);
 697
 698     'expr::aassign::llax_2c1s' => {
 699         desc    => 'non-empty lexical var and array assigned 2 consts and 1 shared var',
 700         setup   => 'my ($x, @a) = 1..4;',
 701         code    => '($x, @a) = (1,2,$x)',
 702     },
 703     'expr::aassign::3l_2c1s' => {
 704         desc    => 'three lexical vars assigned 2 consts and 1 shared var',
 705         setup   => 'my ($x,$y,$z) = 1..3;',
 706         code    => '($x,$y,$z) = (1,2,$x)',
 707     },
 708     'expr::aassign::3p_2c1s' => {
 709         desc    => 'three package vars assigned 2 consts and 1 shared var',
 710         setup   => '($x,$y,$z) = 1..3;',
 711         code    => '($x,$y,$z) = (1,2,$x)',
 712     },
 713
 714
 715     # ($a,$b) = ($b,$a);
 716
 717     'expr::aassign::2l_swap' => {
 718         desc    => 'swap two lexical vars',
 719         setup   => 'my ($a,$b) = (1,2)',
 720         code    => '($a,$b) = ($b,$a)',
 721     },
 722     'expr::aassign::2p_swap' => {
 723         desc    => 'swap two package vars',
 724         setup   => '($a,$b) = (1,2)',
 725         code    => '($a,$b) = ($b,$a)',
 726     },
 727     'expr::aassign::2laelem_swap' => {
 728         desc    => 'swap two lexical vars',
 729         setup   => 'my @a = (1,2)',
 730         code    => '($a[0],$a[1]) = ($a[1],$a[0])',
 731     },
 732
 733     # misc list assign
 734
 735     'expr::aassign::5l_4l1s' => {
 736         desc    => 'long list of lexical vars, 1 shared',
 737         setup   => 'my ($a,$b,$c,$d,$e) = 1..5',
 738         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
 739     },
 740
 741     'expr::aassign::5p_4p1s' => {
 742         desc    => 'long list of package vars, 1 shared',
 743         setup   => '($a,$b,$c,$d,$e) = 1..5',
 744         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
 745     },
 746     'expr::aassign::5l_defary' => {
 747         desc    => 'long list of lexical vars to assign @_ to',
 748         setup   => '@_ = 1..5',
 749         code    => 'my ($a,$b,$c,$d,$e) = @_',
 750     },
 751     'expr::aassign::5l1la_defary' => {
 752         desc    => 'long list of lexical vars plus long slurp to assign @_ to',
 753         setup   => '@_ = 1..20',
 754         code    => 'my ($a,$b,$c,$d,$e,@rest) = @_',
 755     },
 756     'expr::aassign::1l_2l' => {
 757         desc    => 'single lexical LHS',
 758         setup   => 'my $x = 1;',
 759         code    => '(undef,$x) = ($x,$x)',
 760     },
 761     'expr::aassign::2l_1l' => {
 762         desc    => 'single lexical RHS',
 763         setup   => 'my $x = 1;',
 764         code    => '($x,$x) = ($x)',
 765     },
 766     'expr::aassign::2l_1ul' => {
 767         desc    => 'undef and single lexical RHS',
 768         setup   => 'my $x = 1;',
 769         code    => '($x,$x) = (undef, $x)',
 770     },
 771
 772     'expr::aassign::2list_lex' => {
 773         desc    => 'lexical ($x, $y) = (1, 2)',
 774         setup   => 'my ($x, $y)',
 775         code    => '($x, $y) = (1, 2)',
 776     },
 777
 778     'expr::aassign::lex_rv' => {
 779         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4)',
 780         setup   => 'my ($r1, $r2, $r3, $r4);
 781                     ($r1, $r2) = (($r3, $r4) = ([],  []));',
 782         code    => '($r1, $r2) = ($r3, $r4)',
 783     },
 784
 785     'expr::aassign::lex_rv1' => {
 786         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4) where ref1,2 are freed',
 787         setup   => 'my ($r1, $r2);',
 788         code    => '($r1, $r2) = ([], []);',
 789     },
 790
 791     # array assign of strings
 792
 793     'expr::aassign::la_3s' => {
 794         desc    => 'assign 3 strings to empty lexical array',
 795         setup   => 'my @a',
 796         code    => '@a = (); @a = qw(abc defg hijkl);',
 797     },
 798     'expr::aassign::la_3ts' => {
 799         desc    => 'assign 3 temp strings to empty lexical array',
 800         setup   => 'my @a',
 801         code    => '@a = (); @a = map $_, qw(abc defg hijkl);',
 802     },
 803     'expr::aassign::lan_3s' => {
 804         desc    => 'assign 3 strings to non-empty lexical array',
 805         setup   => 'my @a = qw(abc defg hijkl)',
 806         code    => '@a = qw(abc defg hijkl);',
 807     },
 808     'expr::aassign::lan_3ts' => {
 809         desc    => 'assign 3 temp strings to non-empty lexical array',
 810         setup   => 'my @a = qw(abc defg hijkl)',
 811         code    => '@a = map $_, qw(abc defg hijkl);',
 812     },
 813
 814     # hash assign of strings
 815
 816     'expr::aassign::lh_2s' => {
 817         desc    => 'assign 2 strings to empty lexical hash',
 818         setup   => 'my %h',
 819         code    => '%h = (); %h = qw(k1 abc k2 defg);',
 820     },
 821     'expr::aassign::lh_2ts' => {
 822         desc    => 'assign 2 temp strings to empty lexical hash',
 823         setup   => 'my %h',
 824         code    => '%h = (); %h = map $_, qw(k1 abc k2 defg);',
 825     },
 826     'expr::aassign::lhn_2s' => {
 827         desc    => 'assign 2 strings to non-empty lexical hash',
 828         setup   => 'my %h = qw(k1 abc k2 defg);',
 829         code    => '%h = qw(k1 abc k2 defg);',
 830     },
 831     'expr::aassign::lhn_2ts' => {
 832         desc    => 'assign 2 temp strings to non-empty lexical hash',
 833         setup   => 'my %h = qw(k1 abc k2 defg);',
 834         code    => '%h = map $_, qw(k1 abc k2 defg);',
 835     },
 836
 837
 838     'expr::arith::add_lex_ii' => {
 839         desc    => 'add two integers and assign to a lexical var',
 840         setup   => 'my ($x,$y,$z) = 1..3;',
 841         code    => '$z = $x + $y',
 842     },
 843     'expr::arith::add_pkg_ii' => {
 844         desc    => 'add two integers and assign to a package var',
 845         setup   => 'my ($x,$y) = 1..2; $z = 3;',
 846         code    => '$z = $x + $y',
 847     },
 848     'expr::arith::add_lex_nn' => {
 849         desc    => 'add two NVs and assign to a lexical var',
 850         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
 851         code    => '$z = $x + $y',
 852     },
 853     'expr::arith::add_pkg_nn' => {
 854         desc    => 'add two NVs and assign to a package var',
 855         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
 856         code    => '$z = $x + $y',
 857     },
 858     'expr::arith::add_lex_ni' => {
 859         desc    => 'add an int and an NV and assign to a lexical var',
 860         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
 861         code    => '$z = $x + $y',
 862     },
 863     'expr::arith::add_pkg_ni' => {
 864         desc    => 'add an int and an NV and assign to a package var',
 865         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
 866         code    => '$z = $x + $y',
 867     },
 868     'expr::arith::add_lex_ss' => {
 869         desc    => 'add two short strings and assign to a lexical var',
 870         setup   => 'my ($x,$y,$z) = ("1", "2", 1);',
 871         code    => '$z = $x + $y; $x = "1"; ',
 872     },
 873
 874     'expr::arith::add_lex_ll' => {
 875         desc    => 'add two long strings and assign to a lexical var',
 876         setup   => 'my ($x,$y,$z) = ("12345", "23456", 1);',
 877         code    => '$z = $x + $y; $x = "12345"; ',
 878     },
 879
 880     'expr::arith::sub_lex_ii' => {
 881         desc    => 'subtract two integers and assign to a lexical var',
 882         setup   => 'my ($x,$y,$z) = 1..3;',
 883         code    => '$z = $x - $y',
 884     },
 885     'expr::arith::sub_pkg_ii' => {
 886         desc    => 'subtract two integers and assign to a package var',
 887         setup   => 'my ($x,$y) = 1..2; $z = 3;',
 888         code    => '$z = $x - $y',
 889     },
 890     'expr::arith::sub_lex_nn' => {
 891         desc    => 'subtract two NVs and assign to a lexical var',
 892         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
 893         code    => '$z = $x - $y',
 894     },
 895     'expr::arith::sub_pkg_nn' => {
 896         desc    => 'subtract two NVs and assign to a package var',
 897         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
 898         code    => '$z = $x - $y',
 899     },
 900     'expr::arith::sub_lex_ni' => {
 901         desc    => 'subtract an int and an NV and assign to a lexical var',
 902         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
 903         code    => '$z = $x - $y',
 904     },
 905     'expr::arith::sub_pkg_ni' => {
 906         desc    => 'subtract an int and an NV and assign to a package var',
 907         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
 908         code    => '$z = $x - $y',
 909     },
 910
 911     'expr::arith::mult_lex_ii' => {
 912         desc    => 'multiply two integers and assign to a lexical var',
 913         setup   => 'my ($x,$y,$z) = 1..3;',
 914         code    => '$z = $x * $y',
 915     },
 916     'expr::arith::mult_pkg_ii' => {
 917         desc    => 'multiply two integers and assign to a package var',
 918         setup   => 'my ($x,$y) = 1..2; $z = 3;',
 919         code    => '$z = $x * $y',
 920     },
 921     'expr::arith::mult_lex_nn' => {
 922         desc    => 'multiply two NVs and assign to a lexical var',
 923         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
 924         code    => '$z = $x * $y',
 925     },
 926     'expr::arith::mult_pkg_nn' => {
 927         desc    => 'multiply two NVs and assign to a package var',
 928         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
 929         code    => '$z = $x * $y',
 930     },
 931     'expr::arith::mult_lex_ni' => {
 932         desc    => 'multiply an int and an NV and assign to a lexical var',
 933         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
 934         code    => '$z = $x * $y',
 935     },
 936     'expr::arith::mult_pkg_ni' => {
 937         desc    => 'multiply an int and an NV and assign to a package var',
 938         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
 939         code    => '$z = $x * $y',
 940     },
 941
 942     'expr::arith::preinc' => {
 943         desc    => '++$x',
 944         setup   => 'my $x = 1;',
 945         code    => '++$x',
 946     },
 947     'expr::arith::predec' => {
 948         desc    => '--$x',
 949         setup   => 'my $x = 1;',
 950         code    => '--$x',
 951     },
 952     'expr::arith::postinc' => {
 953         desc    => '$x++',
 954         setup   => 'my $x = 1; my $y',
 955         code    => '$y = $x++', # scalar context so not optimised to ++$x
 956     },
 957     'expr::arith::postdec' => {
 958         desc    => '$x--',
 959         setup   => 'my $x = 1; my $y',
 960         code    => '$y = $x--', # scalar context so not optimised to --$x
 961     },
 962
 963
 964
 965     # scalar assign, OP_SASSIGN
 966
 967
 968     'expr::sassign::scalar_lex_int' => {
 969         desc    => 'lexical $x = 1',
 970         setup   => 'my $x',
 971         code    => '$x = 1',
 972     },
 973     'expr::sassign::scalar_lex_str' => {
 974         desc    => 'lexical $x = "abc"',
 975         setup   => 'my $x',
 976         code    => '$x = "abc"',
 977     },
 978     'expr::sassign::scalar_lex_strint' => {
 979         desc    => 'lexical $x = 1 where $x was previously a string',
 980         setup   => 'my $x = "abc"',
 981         code    => '$x = 1',
 982     },
 983     'expr::sassign::scalar_lex_intstr' => {
 984         desc    => 'lexical $x = "abc" where $x was previously an int',
 985         setup   => 'my $x = 1;',
 986         code    => '$x = "abc"',
 987     },
 988     'expr::sassign::lex_rv' => {
 989         desc    => 'lexical $ref1 = $ref2;',
 990         setup   => 'my $r1 = []; my $r = $r1;',
 991         code    => '$r = $r1;',
 992     },
 993     'expr::sassign::lex_rv1' => {
 994         desc    => 'lexical $ref1 = $ref2; where $$ref1 gets freed',
 995         setup   => 'my $r1 = []; my $r',
 996         code    => '$r = []; $r = $r1;',
 997     },
 998
 999
1000
1001     # using a const string as second arg to index triggers using FBM.
1002     # the FBM matcher special-cases 1,2-byte strings.
1003     #
1004     'func::index::short_const1' => {
1005         desc    => 'index of a short string against a 1 char const substr',
1006         setup   => 'my $x = "aaaab"',
1007         code    => 'index $x, "b"',
1008     },
1009     'func::index::long_const1' => {
1010         desc    => 'index of a long string against a 1 char const substr',
1011         setup   => 'my $x = "a" x 1000 . "b"',
1012         code    => 'index $x, "b"',
1013     },
1014     'func::index::short_const2aabc_bc' => {
1015         desc    => 'index of a short string against a 2 char const substr',
1016         setup   => 'my $x = "aaaabc"',
1017         code    => 'index $x, "bc"',
1018     },
1019     'func::index::long_const2aabc_bc' => {
1020         desc    => 'index of a long string against a 2 char const substr',
1021         setup   => 'my $x = "a" x 1000 . "bc"',
1022         code    => 'index $x, "bc"',
1023     },
1024     'func::index::long_const2aa_ab' => {
1025         desc    => 'index of a long string aaa.. against const substr "ab"',
1026         setup   => 'my $x = "a" x 1000',
1027         code    => 'index $x, "ab"',
1028     },
1029     'func::index::long_const2bb_ab' => {
1030         desc    => 'index of a long string bbb.. against const substr "ab"',
1031         setup   => 'my $x = "b" x 1000',
1032         code    => 'index $x, "ab"',
1033     },
1034     'func::index::long_const2aa_bb' => {
1035         desc    => 'index of a long string aaa.. against const substr "bb"',
1036         setup   => 'my $x = "a" x 1000',
1037         code    => 'index $x, "bb"',
1038     },
1039     # this one is designed to be pathological
1040     'func::index::long_const2ab_aa' => {
1041         desc    => 'index of a long string abab.. against const substr "aa"',
1042         setup   => 'my $x = "ab" x 500',
1043         code    => 'index $x, "aa"',
1044     },
1045     # near misses with gaps, 1st letter
1046     'func::index::long_const2aaxx_xy' => {
1047         desc    => 'index of a long string with "xx"s against const substr "xy"',
1048         setup   => 'my $x = "aaaaaaaaxx" x 100',
1049         code    => 'index $x, "xy"',
1050     },
1051     # near misses with gaps, 2nd letter
1052     'func::index::long_const2aayy_xy' => {
1053         desc    => 'index of a long string with "yy"s against const substr "xy"',
1054         setup   => 'my $x = "aaaaaaaayy" x 100',
1055         code    => 'index $x, "xy"',
1056     },
1057     # near misses with gaps, duplicate letter
1058     'func::index::long_const2aaxy_xx' => {
1059         desc    => 'index of a long string with "xy"s against const substr "xx"',
1060         setup   => 'my $x = "aaaaaaaaxy" x 100',
1061         code    => 'index $x, "xx"',
1062     },
1063     # alternating near misses with gaps
1064     'func::index::long_const2aaxxaayy_xy' => {
1065         desc    => 'index of a long string with "xx/yy"s against const substr "xy"',
1066         setup   => 'my $x = "aaaaaaaaxxbbbbbbbbyy" x 50',
1067         code    => 'index $x, "xy"',
1068     },
1069     'func::index::short_const3aabcd_bcd' => {
1070         desc    => 'index of a short string against a 3 char const substr',
1071         setup   => 'my $x = "aaaabcd"',
1072         code    => 'index $x, "bcd"',
1073     },
1074     'func::index::long_const3aabcd_bcd' => {
1075         desc    => 'index of a long string against a 3 char const substr',
1076         setup   => 'my $x = "a" x 1000 . "bcd"',
1077         code    => 'index $x, "bcd"',
1078     },
1079     'func::index::long_const3ab_abc' => {
1080         desc    => 'index of a long string of "ab"s against a 3 char const substr "abc"',
1081         setup   => 'my $x = "ab" x 500',
1082         code    => 'index $x, "abc"',
1083     },
1084     'func::index::long_const3bc_abc' => {
1085         desc    => 'index of a long string of "bc"s against a 3 char const substr "abc"',
1086         setup   => 'my $x = "bc" x 500',
1087         code    => 'index $x, "abc"',
1088     },
1089     'func::index::utf8_position_1' => {
1090         desc    => 'index of a utf8 string, matching at position 1',
1091         setup   => 'my $x = "abc". chr(0x100); chop $x',
1092         code    => 'index $x, "b"',
1093     },
1094
1095
1096
1097     'func::sort::num' => {
1098         desc    => 'plain numeric sort',
1099         setup   => 'my (@a, @b); @a = reverse 1..10;',
1100         code    => '@b = sort { $a <=> $b } @a',
1101     },
1102     'func::sort::num_block' => {
1103         desc    => 'codeblock numeric sort',
1104         setup   => 'my (@a, @b); @a = reverse 1..10;',
1105         code    => '@b = sort { $a + 1 <=> $b + 1 } @a',
1106     },
1107     'func::sort::num_fn' => {
1108         desc    => 'function numeric sort',
1109         setup   => 'sub f { $a + 1 <=> $b + 1 } my (@a, @b); @a = reverse 1..10;',
1110         code    => '@b = sort f @a',
1111     },
1112     'func::sort::str' => {
1113         desc    => 'plain string sort',
1114         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1115         code    => '@b = sort { $a cmp $b } @a',
1116     },
1117     'func::sort::str_block' => {
1118         desc    => 'codeblock string sort',
1119         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1120         code    => '@b = sort { ($a . "") cmp ($b . "") } @a',
1121     },
1122     'func::sort::str_fn' => {
1123         desc    => 'function string sort',
1124         setup   => 'sub f { ($a . "") cmp ($b . "") } my (@a, @b); @a = reverse  "a".."j";',
1125         code    => '@b = sort f @a',
1126     },
1127
1128     'func::sort::num_inplace' => {
1129         desc    => 'plain numeric sort in-place',
1130         setup   => 'my @a = reverse 1..10;',
1131         code    => '@a = sort { $a <=> $b } @a',
1132     },
1133     'func::sort::num_block_inplace' => {
1134         desc    => 'codeblock numeric sort in-place',
1135         setup   => 'my @a = reverse 1..10;',
1136         code    => '@a = sort { $a + 1 <=> $b + 1 } @a',
1137     },
1138     'func::sort::num_fn_inplace' => {
1139         desc    => 'function numeric sort in-place',
1140         setup   => 'sub f { $a + 1 <=> $b + 1 } my @a = reverse 1..10;',
1141         code    => '@a = sort f @a',
1142     },
1143     'func::sort::str_inplace' => {
1144         desc    => 'plain string sort in-place',
1145         setup   => 'my @a = reverse "a".."j";',
1146         code    => '@a = sort { $a cmp $b } @a',
1147     },
1148     'func::sort::str_block_inplace' => {
1149         desc    => 'codeblock string sort in-place',
1150         setup   => 'my @a = reverse "a".."j";',
1151         code    => '@a = sort { ($a . "") cmp ($b . "") } @a',
1152     },
1153     'func::sort::str_fn_inplace' => {
1154         desc    => 'function string sort in-place',
1155         setup   => 'sub f { ($a . "") cmp ($b . "") } my @a = reverse  "a".."j";',
1156         code    => '@a = sort f @a',
1157     },
1158
1159
1160     'func::split::vars' => {
1161         desc    => 'split into two lexical vars',
1162         setup   => 'my $s = "abc:def";',
1163         code    => 'my ($x, $y) = split /:/, $s, 2;',
1164     },
1165
1166     'func::split::array' => {
1167         desc    => 'split into a lexical array',
1168         setup   => 'my @a; my $s = "abc:def";',
1169         code    => '@a = split /:/, $s, 2;',
1170     },
1171     'func::split::myarray' => {
1172         desc    => 'split into a lexical array declared in the assign',
1173         setup   => 'my $s = "abc:def";',
1174         code    => 'my @a = split /:/, $s, 2;',
1175     },
1176     'func::split::arrayexpr' => {
1177         desc    => 'split into an @{$expr} ',
1178         setup   => 'my $s = "abc:def"; my $r = []',
1179         code    => '@$r = split /:/, $s, 2;',
1180     },
1181     'func::split::arraylist' => {
1182         desc    => 'split into an array with extra arg',
1183         setup   => 'my @a; my $s = "abc:def";',
1184         code    => '@a = (split(/:/, $s, 2), 1);',
1185     },
1186
1187
1188     'loop::block' => {
1189         desc    => 'empty basic loop',
1190         setup   => '',
1191         code    => '{1;}',
1192     },
1193
1194     'loop::do' => {
1195         desc    => 'basic do block',
1196         setup   => 'my $x; my $y = 2;',
1197         code    => '$x = do {1; $y}', # the ';' stops the do being optimised
1198     },
1199
1200     'loop::for::my_range1' => {
1201         desc    => 'empty for loop with my var and 1 integer range',
1202         setup   => '',
1203         code    => 'for my $x (1..1) {}',
1204     },
1205     'loop::for::lex_range1' => {
1206         desc    => 'empty for loop with lexical var and 1 integer range',
1207         setup   => 'my $x;',
1208         code    => 'for $x (1..1) {}',
1209     },
1210     'loop::for::pkg_range1' => {
1211         desc    => 'empty for loop with package var and 1 integer range',
1212         setup   => '$x = 1;',
1213         code    => 'for $x (1..1) {}',
1214     },
1215     'loop::for::defsv_range1' => {
1216         desc    => 'empty for loop with $_ and integer 1 range',
1217         setup   => ';',
1218         code    => 'for (1..1) {}',
1219     },
1220     'loop::for::my_range4' => {
1221         desc    => 'empty for loop with my var and 4 integer range',
1222         setup   => '',
1223         code    => 'for my $x (1..4) {}',
1224     },
1225     'loop::for::lex_range4' => {
1226         desc    => 'empty for loop with lexical var and 4 integer range',
1227         setup   => 'my $x;',
1228         code    => 'for $x (1..4) {}',
1229     },
1230     'loop::for::pkg_range4' => {
1231         desc    => 'empty for loop with package var and 4 integer range',
1232         setup   => '$x = 1;',
1233         code    => 'for $x (1..4) {}',
1234     },
1235     'loop::for::defsv_range4' => {
1236         desc    => 'empty for loop with $_ and integer 4 range',
1237         setup   => ';',
1238         code    => 'for (1..4) {}',
1239     },
1240
1241     'loop::for::my_list1' => {
1242         desc    => 'empty for loop with my var and 1 integer list',
1243         setup   => '',
1244         code    => 'for my $x (1) {}',
1245     },
1246     'loop::for::lex_list1' => {
1247         desc    => 'empty for loop with lexical var and 1 integer list',
1248         setup   => 'my $x;',
1249         code    => 'for $x (1) {}',
1250     },
1251     'loop::for::pkg_list1' => {
1252         desc    => 'empty for loop with package var and 1 integer list',
1253         setup   => '$x = 1;',
1254         code    => 'for $x (1) {}',
1255     },
1256     'loop::for::defsv_list1' => {
1257         desc    => 'empty for loop with $_ and integer 1 list',
1258         setup   => ';',
1259         code    => 'for (1) {}',
1260     },
1261     'loop::for::my_list4' => {
1262         desc    => 'empty for loop with my var and 4 integer list',
1263         setup   => '',
1264         code    => 'for my $x (1,2,3,4) {}',
1265     },
1266     'loop::for::lex_list4' => {
1267         desc    => 'empty for loop with lexical var and 4 integer list',
1268         setup   => 'my $x;',
1269         code    => 'for $x (1,2,3,4) {}',
1270     },
1271     'loop::for::pkg_list4' => {
1272         desc    => 'empty for loop with package var and 4 integer list',
1273         setup   => '$x = 1;',
1274         code    => 'for $x (1,2,3,4) {}',
1275     },
1276     'loop::for::defsv_list4' => {
1277         desc    => 'empty for loop with $_ and integer 4 list',
1278         setup   => '',
1279         code    => 'for (1,2,3,4) {}',
1280     },
1281
1282     'loop::for::my_array1' => {
1283         desc    => 'empty for loop with my var and 1 integer array',
1284         setup   => 'my @a = (1);',
1285         code    => 'for my $x (@a) {}',
1286     },
1287     'loop::for::lex_array1' => {
1288         desc    => 'empty for loop with lexical var and 1 integer array',
1289         setup   => 'my $x; my @a = (1);',
1290         code    => 'for $x (@a) {}',
1291     },
1292     'loop::for::pkg_array1' => {
1293         desc    => 'empty for loop with package var and 1 integer array',
1294         setup   => '$x = 1; my @a = (1);',
1295         code    => 'for $x (@a) {}',
1296     },
1297     'loop::for::defsv_array1' => {
1298         desc    => 'empty for loop with $_ and integer 1 array',
1299         setup   => 'my @a = (@a);',
1300         code    => 'for (1) {}',
1301     },
1302     'loop::for::my_array4' => {
1303         desc    => 'empty for loop with my var and 4 integer array',
1304         setup   => 'my @a = (1..4);',
1305         code    => 'for my $x (@a) {}',
1306     },
1307     'loop::for::lex_array4' => {
1308         desc    => 'empty for loop with lexical var and 4 integer array',
1309         setup   => 'my $x; my @a = (1..4);',
1310         code    => 'for $x (@a) {}',
1311     },
1312     'loop::for::pkg_array4' => {
1313         desc    => 'empty for loop with package var and 4 integer array',
1314         setup   => '$x = 1; my @a = (1..4);',
1315         code    => 'for $x (@a) {}',
1316     },
1317     'loop::for::defsv_array4' => {
1318         desc    => 'empty for loop with $_ and integer 4 array',
1319         setup   => 'my @a = (1..4);',
1320         code    => 'for (@a) {}',
1321     },
1322
1323     'loop::for::next4' => {
1324         desc    => 'for loop containing only next with my var and integer 4 array',
1325         setup   => 'my @a = (1..4);',
1326         code    => 'for my $x (@a) {next}',
1327     },
1328
1329     'loop::grep::expr_3int' => {
1330         desc    => 'grep $_ > 0, 1,2,3',
1331         setup   => 'my @a',
1332         code    => '@a = grep $_ > 0, 1,2,3',
1333     },
1334
1335     'loop::grep::block_3int' => {
1336         desc    => 'grep { 1; $_ > 0} 1,2,3',
1337         setup   => 'my @a',
1338         code    => '@a = grep { 1; $_ > 0} 1,2,3',
1339     },
1340
1341     'loop::map::expr_3int' => {
1342         desc    => 'map $_+1, 1,2,3',
1343         setup   => 'my @a',
1344         code    => '@a = map $_+1, 1,2,3',
1345     },
1346
1347     'loop::map::block_3int' => {
1348         desc    => 'map { 1; $_+1} 1,2,3',
1349         setup   => 'my @a',
1350         code    => '@a = map { 1; $_+1} 1,2,3',
1351     },
1352
1353     'loop::while::i1' => {
1354         desc    => 'empty while loop 1 iteration',
1355         setup   => 'my $i = 0;',
1356         code    => 'while (++$i % 2) {}',
1357     },
1358     'loop::while::i4' => {
1359         desc    => 'empty while loop 4 iterations',
1360         setup   => 'my $i = 0;',
1361         code    => 'while (++$i % 4) {}',
1362     },
1363
1364
1365     'regex::anyof_plus::anchored' => {
1366         desc    => '/^[acgt]+/',
1367         setup   => '$_ = "a" x 100;',
1368         code    => '/^[acgt]+/',
1369     },
1370     'regex::anyof_plus::floating' => {
1371         desc    => '/[acgt]+where match starts at position 0 for 100 chars/',
1372         setup   => '$_ = "a" x 100;',
1373         code    => '/[acgt]+/',
1374     },
1375     'regex::anyof_plus::floating_away' => {
1376         desc    => '/[acgt]+/ where match starts at position 100 for 100 chars',
1377         setup   => '$_ = ("0" x 100) . ("a" x 100);',
1378         code    => '/[acgt]+/',
1379     },
1380 ];