This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regexes: make scanning for ANYOF faster
[perl5.git] / 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     (
305         map {
306             sprintf('expr::hash::notexists_lex_keylen%04d',$_) => {
307                 desc    => 'exists on non-key of length '. $_,
308                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key."x"} = 1;',
309                 code    => 'exists $h{$key}',
310             },
311         } (
312             1 .. 24,
313             # 1,2,3,7,8,9,14,15,16,20,24,
314             50,
315             100,
316             1000,
317         )
318     ),
319     (
320         map {
321             sprintf('expr::hash::exists_lex_keylen%04d',$_) => {
322                 desc    => 'exists on existing key of length '. $_,
323                 setup   => 'my %h; my $key = "A" x ' . $_ . '; $h{$key} = 1;',
324                 code    => 'exists $h{$key}',
325             },
326         } (
327             1 .. 24,
328             # 1,2,3,7,8,9,14,15,16,20,24,
329             50,
330             100,
331             1000,
332         )
333     ),
334
335     'expr::hash::delete_lex_2var' => {
336         desc    => 'lexical delete $hash{$k1}{$k2}',
337         setup   => 'my ($k1,$k2) = qw(foo bar); my %h = ($k1 => { $k2 => 1 });',
338         code    => 'delete $h{$k1}{$k2}',
339     },
340
341
342     # list assign, OP_AASSIGN
343
344
345     # (....) = ()
346
347     'expr::aassign::ma_empty' => {
348         desc    => 'my array assigned empty',
349         setup   => '',
350         code    => 'my @a = ()',
351     },
352     'expr::aassign::lax_empty' => {
353         desc    => 'non-empty lexical array assigned empty',
354         setup   => 'my @a = 1..3;',
355         code    => '@a = ()',
356     },
357     'expr::aassign::llax_empty' => {
358         desc    => 'non-empty lexical var and array assigned empty',
359         setup   => 'my ($x, @a) = 1..4;',
360         code    => '($x, @a) = ()',
361     },
362     'expr::aassign::mh_empty' => {
363         desc    => 'my hash assigned empty',
364         setup   => '',
365         code    => 'my %h = ()',
366     },
367     'expr::aassign::lhx_empty' => {
368         desc    => 'non-empty lexical hash assigned empty',
369         setup   => 'my %h = 1..4;',
370         code    => '%h = ()',
371     },
372     'expr::aassign::llhx_empty' => {
373         desc    => 'non-empty lexical var and hash assigned empty',
374         setup   => 'my ($x, %h) = 1..5;',
375         code    => '($x, %h) = ()',
376     },
377     'expr::aassign::3m_empty' => {
378         desc    => 'three my vars assigned empty',
379         setup   => '',
380         code    => 'my ($x,$y,$z) = ()',
381     },
382     'expr::aassign::3l_empty' => {
383         desc    => 'three lexical vars assigned empty',
384         setup   => 'my ($x,$y,$z)',
385         code    => '($x,$y,$z) = ()',
386     },
387     'expr::aassign::3lref_empty' => {
388         desc    => 'three lexical ref vars assigned empty',
389         setup   => 'my ($x,$y,$z); my $r = []; ',
390         code    => '($x,$y,$z) = ($r,$r,$r); ($x,$y,$z) = ()',
391     },
392     'expr::aassign::pa_empty' => {
393         desc    => 'package array assigned empty',
394         setup   => '',
395         code    => '@a = ()',
396     },
397     'expr::aassign::pax_empty' => {
398         desc    => 'non-empty package array assigned empty',
399         setup   => '@a = (1,2,3)',
400         code    => '@a = ()',
401     },
402     'expr::aassign::3p_empty' => {
403         desc    => 'three package vars assigned empty',
404         setup   => '($x,$y,$z) = 1..3;',
405         code    => '($x,$y,$z) = ()',
406     },
407
408     # (....) = (1,2,3)
409
410     'expr::aassign::ma_3c' => {
411         desc    => 'my array assigned 3 consts',
412         setup   => '',
413         code    => 'my @a = (1,2,3)',
414     },
415     'expr::aassign::lax_3c' => {
416         desc    => 'non-empty lexical array assigned 3 consts',
417         setup   => 'my @a = 1..3;',
418         code    => '@a = (1,2,3)',
419     },
420     'expr::aassign::llax_3c' => {
421         desc    => 'non-empty lexical var and array assigned 3 consts',
422         setup   => 'my ($x, @a) = 1..4;',
423         code    => '($x, @a) = (1,2,3)',
424     },
425     'expr::aassign::mh_4c' => {
426         desc    => 'my hash assigned 4 consts',
427         setup   => '',
428         code    => 'my %h = qw(a 1 b 2)',
429     },
430     'expr::aassign::lhx_4c' => {
431         desc    => 'non-empty lexical hash assigned 4 consts',
432         setup   => 'my %h = qw(a 1 b 2);',
433         code    => '%h = qw(c 3 d 4)',
434     },
435     'expr::aassign::llhx_5c' => {
436         desc    => 'non-empty lexical var and array assigned 5 consts',
437         setup   => 'my ($x, %h) = (1, qw(a 1 b 2));',
438         code    => '($x, %h) = (10, qw(c 3 d 4))',
439     },
440     'expr::aassign::3m_3c' => {
441         desc    => 'three my vars assigned 3 consts',
442         setup   => '',
443         code    => 'my ($x,$y,$z) = (1,2,3)',
444     },
445     'expr::aassign::3l_3c' => {
446         desc    => 'three lexical vars assigned 3 consts',
447         setup   => 'my ($x,$y,$z)',
448         code    => '($x,$y,$z) = (1,2,3)',
449     },
450     'expr::aassign::pa_3c' => {
451         desc    => 'package array assigned 3 consts',
452         setup   => '',
453         code    => '@a = (1,2,3)',
454     },
455     'expr::aassign::pax_3c' => {
456         desc    => 'non-empty package array assigned 3 consts',
457         setup   => '@a = (1,2,3)',
458         code    => '@a = (1,2,3)',
459     },
460     'expr::aassign::3p_3c' => {
461         desc    => 'three package vars assigned 3 consts',
462         setup   => '($x,$y,$z) = 1..3;',
463         code    => '($x,$y,$z) = (1,2,3)',
464     },
465
466     # (....) = @lexical
467
468     'expr::aassign::ma_la' => {
469         desc    => 'my array assigned lexical array',
470         setup   => 'my @init = 1..3;',
471         code    => 'my @a = @init',
472     },
473     'expr::aassign::lax_la' => {
474         desc    => 'non-empty lexical array assigned lexical array',
475         setup   => 'my @init = 1..3; my @a = 1..3;',
476         code    => '@a = @init',
477     },
478     'expr::aassign::llax_la' => {
479         desc    => 'non-empty lexical var and array assigned lexical array',
480         setup   => 'my @init = 1..3; my ($x, @a) = 1..4;',
481         code    => '($x, @a) = @init',
482     },
483     'expr::aassign::3m_la' => {
484         desc    => 'three my vars assigned lexical array',
485         setup   => 'my @init = 1..3;',
486         code    => 'my ($x,$y,$z) = @init',
487     },
488     'expr::aassign::3l_la' => {
489         desc    => 'three lexical vars assigned lexical array',
490         setup   => 'my @init = 1..3; my ($x,$y,$z)',
491         code    => '($x,$y,$z) = @init',
492     },
493     'expr::aassign::pa_la' => {
494         desc    => 'package array assigned lexical array',
495         setup   => 'my @init = 1..3;',
496         code    => '@a = @init',
497     },
498     'expr::aassign::pax_la' => {
499         desc    => 'non-empty package array assigned lexical array',
500         setup   => 'my @init = 1..3; @a = @init',
501         code    => '@a = @init',
502     },
503     'expr::aassign::3p_la' => {
504         desc    => 'three package vars assigned lexical array',
505         setup   => 'my @init = 1..3; ($x,$y,$z) = 1..3;',
506         code    => '($x,$y,$z) = @init',
507     },
508
509     # (....) = @package
510
511     'expr::aassign::ma_pa' => {
512         desc    => 'my array assigned package array',
513         setup   => '@init = 1..3;',
514         code    => 'my @a = @init',
515     },
516     'expr::aassign::lax_pa' => {
517         desc    => 'non-empty lexical array assigned package array',
518         setup   => '@init = 1..3; my @a = 1..3;',
519         code    => '@a = @init',
520     },
521     'expr::aassign::llax_pa' => {
522         desc    => 'non-empty lexical var and array assigned package array',
523         setup   => '@init = 1..3; my ($x, @a) = 1..4;',
524         code    => '($x, @a) = @init',
525     },
526     'expr::aassign::3m_pa' => {
527         desc    => 'three my vars assigned package array',
528         setup   => '@init = 1..3;',
529         code    => 'my ($x,$y,$z) = @init',
530     },
531     'expr::aassign::3l_pa' => {
532         desc    => 'three lexical vars assigned package array',
533         setup   => '@init = 1..3; my ($x,$y,$z)',
534         code    => '($x,$y,$z) = @init',
535     },
536     'expr::aassign::pa_pa' => {
537         desc    => 'package array assigned package array',
538         setup   => '@init = 1..3;',
539         code    => '@a = @init',
540     },
541     'expr::aassign::pax_pa' => {
542         desc    => 'non-empty package array assigned package array',
543         setup   => '@init = 1..3; @a = @init',
544         code    => '@a = @init',
545     },
546     'expr::aassign::3p_pa' => {
547         desc    => 'three package vars assigned package array',
548         setup   => '@init = 1..3; ($x,$y,$z) = 1..3;',
549         code    => '($x,$y,$z) = @init',
550     },
551
552     # (....) = @_;
553
554     'expr::aassign::ma_defary' => {
555         desc    => 'my array assigned @_',
556         setup   => '@_ = 1..3;',
557         code    => 'my @a = @_',
558     },
559     'expr::aassign::lax_defary' => {
560         desc    => 'non-empty lexical array assigned @_',
561         setup   => '@_ = 1..3; my @a = 1..3;',
562         code    => '@a = @_',
563     },
564     'expr::aassign::llax_defary' => {
565         desc    => 'non-empty lexical var and array assigned @_',
566         setup   => '@_ = 1..3; my ($x, @a) = 1..4;',
567         code    => '($x, @a) = @_',
568     },
569     'expr::aassign::3m_defary' => {
570         desc    => 'three my vars assigned @_',
571         setup   => '@_ = 1..3;',
572         code    => 'my ($x,$y,$z) = @_',
573     },
574     'expr::aassign::3l_defary' => {
575         desc    => 'three lexical vars assigned @_',
576         setup   => '@_ = 1..3; my ($x,$y,$z)',
577         code    => '($x,$y,$z) = @_',
578     },
579     'expr::aassign::pa_defary' => {
580         desc    => 'package array assigned @_',
581         setup   => '@_ = 1..3;',
582         code    => '@a = @_',
583     },
584     'expr::aassign::pax_defary' => {
585         desc    => 'non-empty package array assigned @_',
586         setup   => '@_ = 1..3; @a = @_',
587         code    => '@a = @_',
588     },
589     'expr::aassign::3p_defary' => {
590         desc    => 'three package vars assigned @_',
591         setup   => '@_ = 1..3; ($x,$y,$z) = 1..3;',
592         code    => '($x,$y,$z) = @_',
593     },
594
595
596     # (....) = ($lex1,$lex2,$lex3);
597
598     'expr::aassign::ma_3l' => {
599         desc    => 'my array assigned lexicals',
600         setup   => 'my ($v1,$v2,$v3) = 1..3;',
601         code    => 'my @a = ($v1,$v2,$v3)',
602     },
603     'expr::aassign::lax_3l' => {
604         desc    => 'non-empty lexical array assigned lexicals',
605         setup   => 'my ($v1,$v2,$v3) = 1..3; my @a = 1..3;',
606         code    => '@a = ($v1,$v2,$v3)',
607     },
608     'expr::aassign::llax_3l' => {
609         desc    => 'non-empty lexical var and array assigned lexicals',
610         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
611         code    => '($x, @a) = ($v1,$v2,$v3)',
612     },
613     'expr::aassign::3m_3l' => {
614         desc    => 'three my vars assigned lexicals',
615         setup   => 'my ($v1,$v2,$v3) = 1..3;',
616         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
617     },
618     'expr::aassign::3l_3l' => {
619         desc    => 'three lexical vars assigned lexicals',
620         setup   => 'my ($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
621         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
622     },
623     'expr::aassign::pa_3l' => {
624         desc    => 'package array assigned lexicals',
625         setup   => 'my ($v1,$v2,$v3) = 1..3;',
626         code    => '@a = ($v1,$v2,$v3)',
627     },
628     'expr::aassign::pax_3l' => {
629         desc    => 'non-empty package array assigned lexicals',
630         setup   => 'my ($v1,$v2,$v3) = 1..3; @a = @_',
631         code    => '@a = ($v1,$v2,$v3)',
632     },
633     'expr::aassign::3p_3l' => {
634         desc    => 'three package vars assigned lexicals',
635         setup   => 'my ($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
636         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
637     },
638
639
640     # (....) = ($pkg1,$pkg2,$pkg3);
641
642     'expr::aassign::ma_3p' => {
643         desc    => 'my array assigned 3 package vars',
644         setup   => '($v1,$v2,$v3) = 1..3;',
645         code    => 'my @a = ($v1,$v2,$v3)',
646     },
647     'expr::aassign::lax_3p' => {
648         desc    => 'non-empty lexical array assigned 3 package vars',
649         setup   => '($v1,$v2,$v3) = 1..3; my @a = 1..3;',
650         code    => '@a = ($v1,$v2,$v3)',
651     },
652     'expr::aassign::llax_3p' => {
653         desc    => 'non-empty lexical var and array assigned 3 package vars',
654         setup   => '($v1,$v2,$v3) = 1..3; my ($x, @a) = 1..4;',
655         code    => '($x, @a) = ($v1,$v2,$v3)',
656     },
657     'expr::aassign::3m_3p' => {
658         desc    => 'three my vars assigned 3 package vars',
659         setup   => '($v1,$v2,$v3) = 1..3;',
660         code    => 'my ($x,$y,$z) = ($v1,$v2,$v3)',
661     },
662     'expr::aassign::3l_3p' => {
663         desc    => 'three lexical vars assigned 3 package vars',
664         setup   => '($v1,$v2,$v3) = 1..3; my ($x,$y,$z)',
665         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
666     },
667     'expr::aassign::pa_3p' => {
668         desc    => 'package array assigned 3 package vars',
669         setup   => '($v1,$v2,$v3) = 1..3;',
670         code    => '@a = ($v1,$v2,$v3)',
671     },
672     'expr::aassign::pax_3p' => {
673         desc    => 'non-empty package array assigned 3 package vars',
674         setup   => '($v1,$v2,$v3) = 1..3; @a = @_',
675         code    => '@a = ($v1,$v2,$v3)',
676     },
677     'expr::aassign::3p_3p' => {
678         desc    => 'three package vars assigned 3 package vars',
679         setup   => '($v1,$v2,$v3) = 1..3; ($x,$y,$z) = 1..3;',
680         code    => '($x,$y,$z) = ($v1,$v2,$v3)',
681     },
682
683
684     # (....) = (1,2,$shared);
685
686     'expr::aassign::llax_2c1s' => {
687         desc    => 'non-empty lexical var and array assigned 2 consts and 1 shared var',
688         setup   => 'my ($x, @a) = 1..4;',
689         code    => '($x, @a) = (1,2,$x)',
690     },
691     'expr::aassign::3l_2c1s' => {
692         desc    => 'three lexical vars assigned 2 consts and 1 shared var',
693         setup   => 'my ($x,$y,$z) = 1..3;',
694         code    => '($x,$y,$z) = (1,2,$x)',
695     },
696     'expr::aassign::3p_2c1s' => {
697         desc    => 'three package vars assigned 2 consts and 1 shared var',
698         setup   => '($x,$y,$z) = 1..3;',
699         code    => '($x,$y,$z) = (1,2,$x)',
700     },
701
702
703     # ($a,$b) = ($b,$a);
704
705     'expr::aassign::2l_swap' => {
706         desc    => 'swap two lexical vars',
707         setup   => 'my ($a,$b) = (1,2)',
708         code    => '($a,$b) = ($b,$a)',
709     },
710     'expr::aassign::2p_swap' => {
711         desc    => 'swap two package vars',
712         setup   => '($a,$b) = (1,2)',
713         code    => '($a,$b) = ($b,$a)',
714     },
715     'expr::aassign::2laelem_swap' => {
716         desc    => 'swap two lexical vars',
717         setup   => 'my @a = (1,2)',
718         code    => '($a[0],$a[1]) = ($a[1],$a[0])',
719     },
720
721     # misc list assign
722
723     'expr::aassign::5l_4l1s' => {
724         desc    => 'long list of lexical vars, 1 shared',
725         setup   => 'my ($a,$b,$c,$d,$e) = 1..5',
726         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
727     },
728
729     'expr::aassign::5p_4p1s' => {
730         desc    => 'long list of package vars, 1 shared',
731         setup   => '($a,$b,$c,$d,$e) = 1..5',
732         code    => '($a,$b,$c,$d,$e) = ($a,$a,$c,$d,$e)',
733     },
734     'expr::aassign::5l_defary' => {
735         desc    => 'long list of lexical vars to assign @_ to',
736         setup   => '@_ = 1..5',
737         code    => 'my ($a,$b,$c,$d,$e) = @_',
738     },
739     'expr::aassign::5l1la_defary' => {
740         desc    => 'long list of lexical vars plus long slurp to assign @_ to',
741         setup   => '@_ = 1..20',
742         code    => 'my ($a,$b,$c,$d,$e,@rest) = @_',
743     },
744     'expr::aassign::1l_2l' => {
745         desc    => 'single lexical LHS',
746         setup   => 'my $x = 1;',
747         code    => '(undef,$x) = ($x,$x)',
748     },
749     'expr::aassign::2l_1l' => {
750         desc    => 'single lexical RHS',
751         setup   => 'my $x = 1;',
752         code    => '($x,$x) = ($x)',
753     },
754     'expr::aassign::2l_1ul' => {
755         desc    => 'undef and single lexical RHS',
756         setup   => 'my $x = 1;',
757         code    => '($x,$x) = (undef, $x)',
758     },
759
760     'expr::aassign::2list_lex' => {
761         desc    => 'lexical ($x, $y) = (1, 2)',
762         setup   => 'my ($x, $y)',
763         code    => '($x, $y) = (1, 2)',
764     },
765
766     'expr::aassign::lex_rv' => {
767         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4)',
768         setup   => 'my ($r1, $r2, $r3, $r4);
769                     ($r1, $r2) = (($r3, $r4) = ([],  []));',
770         code    => '($r1, $r2) = ($r3, $r4)',
771     },
772
773     'expr::aassign::lex_rv1' => {
774         desc    => 'lexical ($ref1, $ref2) = ($ref3, $ref4) where ref1,2 are freed',
775         setup   => 'my ($r1, $r2);',
776         code    => '($r1, $r2) = ([], []);',
777     },
778
779     # array assign of strings
780
781     'expr::aassign::la_3s' => {
782         desc    => 'assign 3 strings to empty lexical array',
783         setup   => 'my @a',
784         code    => '@a = (); @a = qw(abc defg hijkl);',
785     },
786     'expr::aassign::la_3ts' => {
787         desc    => 'assign 3 temp strings to empty lexical array',
788         setup   => 'my @a',
789         code    => '@a = (); @a = map $_, qw(abc defg hijkl);',
790     },
791     'expr::aassign::lan_3s' => {
792         desc    => 'assign 3 strings to non-empty lexical array',
793         setup   => 'my @a = qw(abc defg hijkl)',
794         code    => '@a = qw(abc defg hijkl);',
795     },
796     'expr::aassign::lan_3ts' => {
797         desc    => 'assign 3 temp strings to non-empty lexical array',
798         setup   => 'my @a = qw(abc defg hijkl)',
799         code    => '@a = map $_, qw(abc defg hijkl);',
800     },
801
802     # hash assign of strings
803
804     'expr::aassign::lh_2s' => {
805         desc    => 'assign 2 strings to empty lexical hash',
806         setup   => 'my %h',
807         code    => '%h = (); %h = qw(k1 abc k2 defg);',
808     },
809     'expr::aassign::lh_2ts' => {
810         desc    => 'assign 2 temp strings to empty lexical hash',
811         setup   => 'my %h',
812         code    => '%h = (); %h = map $_, qw(k1 abc k2 defg);',
813     },
814     'expr::aassign::lhn_2s' => {
815         desc    => 'assign 2 strings to non-empty lexical hash',
816         setup   => 'my %h = qw(k1 abc k2 defg);',
817         code    => '%h = qw(k1 abc k2 defg);',
818     },
819     'expr::aassign::lhn_2ts' => {
820         desc    => 'assign 2 temp strings to non-empty lexical hash',
821         setup   => 'my %h = qw(k1 abc k2 defg);',
822         code    => '%h = map $_, qw(k1 abc k2 defg);',
823     },
824
825
826     'expr::arith::add_lex_ii' => {
827         desc    => 'add two integers and assign to a lexical var',
828         setup   => 'my ($x,$y,$z) = 1..3;',
829         code    => '$z = $x + $y',
830     },
831     'expr::arith::add_pkg_ii' => {
832         desc    => 'add two integers and assign to a package var',
833         setup   => 'my ($x,$y) = 1..2; $z = 3;',
834         code    => '$z = $x + $y',
835     },
836     'expr::arith::add_lex_nn' => {
837         desc    => 'add two NVs and assign to a lexical var',
838         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
839         code    => '$z = $x + $y',
840     },
841     'expr::arith::add_pkg_nn' => {
842         desc    => 'add two NVs and assign to a package var',
843         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
844         code    => '$z = $x + $y',
845     },
846     'expr::arith::add_lex_ni' => {
847         desc    => 'add an int and an NV and assign to a lexical var',
848         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
849         code    => '$z = $x + $y',
850     },
851     'expr::arith::add_pkg_ni' => {
852         desc    => 'add an int and an NV and assign to a package var',
853         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
854         code    => '$z = $x + $y',
855     },
856     'expr::arith::add_lex_ss' => {
857         desc    => 'add two short strings and assign to a lexical var',
858         setup   => 'my ($x,$y,$z) = ("1", "2", 1);',
859         code    => '$z = $x + $y; $x = "1"; ',
860     },
861
862     'expr::arith::add_lex_ll' => {
863         desc    => 'add two long strings and assign to a lexical var',
864         setup   => 'my ($x,$y,$z) = ("12345", "23456", 1);',
865         code    => '$z = $x + $y; $x = "12345"; ',
866     },
867
868     'expr::arith::sub_lex_ii' => {
869         desc    => 'subtract two integers and assign to a lexical var',
870         setup   => 'my ($x,$y,$z) = 1..3;',
871         code    => '$z = $x - $y',
872     },
873     'expr::arith::sub_pkg_ii' => {
874         desc    => 'subtract two integers and assign to a package var',
875         setup   => 'my ($x,$y) = 1..2; $z = 3;',
876         code    => '$z = $x - $y',
877     },
878     'expr::arith::sub_lex_nn' => {
879         desc    => 'subtract two NVs and assign to a lexical var',
880         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
881         code    => '$z = $x - $y',
882     },
883     'expr::arith::sub_pkg_nn' => {
884         desc    => 'subtract two NVs and assign to a package var',
885         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
886         code    => '$z = $x - $y',
887     },
888     'expr::arith::sub_lex_ni' => {
889         desc    => 'subtract an int and an NV and assign to a lexical var',
890         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
891         code    => '$z = $x - $y',
892     },
893     'expr::arith::sub_pkg_ni' => {
894         desc    => 'subtract an int and an NV and assign to a package var',
895         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
896         code    => '$z = $x - $y',
897     },
898
899     'expr::arith::mult_lex_ii' => {
900         desc    => 'multiply two integers and assign to a lexical var',
901         setup   => 'my ($x,$y,$z) = 1..3;',
902         code    => '$z = $x * $y',
903     },
904     'expr::arith::mult_pkg_ii' => {
905         desc    => 'multiply two integers and assign to a package var',
906         setup   => 'my ($x,$y) = 1..2; $z = 3;',
907         code    => '$z = $x * $y',
908     },
909     'expr::arith::mult_lex_nn' => {
910         desc    => 'multiply two NVs and assign to a lexical var',
911         setup   => 'my ($x,$y,$z) = (1.1, 2.2, 3.3);',
912         code    => '$z = $x * $y',
913     },
914     'expr::arith::mult_pkg_nn' => {
915         desc    => 'multiply two NVs and assign to a package var',
916         setup   => 'my ($x,$y); ($x,$y,$z) = (1.1, 2.2, 3.3);',
917         code    => '$z = $x * $y',
918     },
919     'expr::arith::mult_lex_ni' => {
920         desc    => 'multiply an int and an NV and assign to a lexical var',
921         setup   => 'my ($x,$y,$z) = (1, 2.2, 3.3);',
922         code    => '$z = $x * $y',
923     },
924     'expr::arith::mult_pkg_ni' => {
925         desc    => 'multiply an int and an NV and assign to a package var',
926         setup   => 'my ($x,$y); ($x,$y,$z) = (1, 2.2, 3.3);',
927         code    => '$z = $x * $y',
928     },
929
930     'expr::arith::preinc' => {
931         desc    => '++$x',
932         setup   => 'my $x = 1;',
933         code    => '++$x',
934     },
935     'expr::arith::predec' => {
936         desc    => '--$x',
937         setup   => 'my $x = 1;',
938         code    => '--$x',
939     },
940     'expr::arith::postinc' => {
941         desc    => '$x++',
942         setup   => 'my $x = 1; my $y',
943         code    => '$y = $x++', # scalar context so not optimised to ++$x
944     },
945     'expr::arith::postdec' => {
946         desc    => '$x--',
947         setup   => 'my $x = 1; my $y',
948         code    => '$y = $x--', # scalar context so not optimised to --$x
949     },
950
951
952
953     # scalar assign, OP_SASSIGN
954    
955
956     'expr::sassign::scalar_lex_int' => {
957         desc    => 'lexical $x = 1',
958         setup   => 'my $x',
959         code    => '$x = 1',
960     },
961     'expr::sassign::scalar_lex_str' => {
962         desc    => 'lexical $x = "abc"',
963         setup   => 'my $x',
964         code    => '$x = "abc"',
965     },
966     'expr::sassign::scalar_lex_strint' => {
967         desc    => 'lexical $x = 1 where $x was previously a string',
968         setup   => 'my $x = "abc"',
969         code    => '$x = 1',
970     },
971     'expr::sassign::scalar_lex_intstr' => {
972         desc    => 'lexical $x = "abc" where $x was previously an int',
973         setup   => 'my $x = 1;',
974         code    => '$x = "abc"',
975     },
976     'expr::sassign::lex_rv' => {
977         desc    => 'lexical $ref1 = $ref2;',
978         setup   => 'my $r1 = []; my $r = $r1;',
979         code    => '$r = $r1;',
980     },
981     'expr::sassign::lex_rv1' => {
982         desc    => 'lexical $ref1 = $ref2; where $$ref1 gets freed',
983         setup   => 'my $r1 = []; my $r',
984         code    => '$r = []; $r = $r1;',
985     },
986
987
988
989     # using a const string as second arg to index triggers using FBM.
990     # the FBM matcher special-cases 1,2-byte strings.
991     #
992     'func::index::short_const1' => {
993         desc    => 'index of a short string against a 1 char const substr',
994         setup   => 'my $x = "aaaab"',
995         code    => 'index $x, "b"',
996     },
997     'func::index::long_const1' => {
998         desc    => 'index of a long string against a 1 char const substr',
999         setup   => 'my $x = "a" x 1000 . "b"',
1000         code    => 'index $x, "b"',
1001     },
1002     'func::index::short_const2aabc_bc' => {
1003         desc    => 'index of a short string against a 2 char const substr',
1004         setup   => 'my $x = "aaaabc"',
1005         code    => 'index $x, "bc"',
1006     },
1007     'func::index::long_const2aabc_bc' => {
1008         desc    => 'index of a long string against a 2 char const substr',
1009         setup   => 'my $x = "a" x 1000 . "bc"',
1010         code    => 'index $x, "bc"',
1011     },
1012     'func::index::long_const2aa_ab' => {
1013         desc    => 'index of a long string aaa.. against const substr "ab"',
1014         setup   => 'my $x = "a" x 1000',
1015         code    => 'index $x, "ab"',
1016     },
1017     'func::index::long_const2bb_ab' => {
1018         desc    => 'index of a long string bbb.. against const substr "ab"',
1019         setup   => 'my $x = "b" x 1000',
1020         code    => 'index $x, "ab"',
1021     },
1022     'func::index::long_const2aa_bb' => {
1023         desc    => 'index of a long string aaa.. against const substr "bb"',
1024         setup   => 'my $x = "a" x 1000',
1025         code    => 'index $x, "bb"',
1026     },
1027     # this one is designed to be pathological
1028     'func::index::long_const2ab_aa' => {
1029         desc    => 'index of a long string abab.. against const substr "aa"',
1030         setup   => 'my $x = "ab" x 500',
1031         code    => 'index $x, "aa"',
1032     },
1033     # near misses with gaps, 1st letter
1034     'func::index::long_const2aaxx_xy' => {
1035         desc    => 'index of a long string with "xx"s against const substr "xy"',
1036         setup   => 'my $x = "aaaaaaaaxx" x 100',
1037         code    => 'index $x, "xy"',
1038     },
1039     # near misses with gaps, 2nd letter
1040     'func::index::long_const2aayy_xy' => {
1041         desc    => 'index of a long string with "yy"s against const substr "xy"',
1042         setup   => 'my $x = "aaaaaaaayy" x 100',
1043         code    => 'index $x, "xy"',
1044     },
1045     # near misses with gaps, duplicate letter
1046     'func::index::long_const2aaxy_xx' => {
1047         desc    => 'index of a long string with "xy"s against const substr "xx"',
1048         setup   => 'my $x = "aaaaaaaaxy" x 100',
1049         code    => 'index $x, "xx"',
1050     },
1051     # alternating near misses with gaps
1052     'func::index::long_const2aaxxaayy_xy' => {
1053         desc    => 'index of a long string with "xx/yy"s against const substr "xy"',
1054         setup   => 'my $x = "aaaaaaaaxxbbbbbbbbyy" x 50',
1055         code    => 'index $x, "xy"',
1056     },
1057     'func::index::short_const3aabcd_bcd' => {
1058         desc    => 'index of a short string against a 3 char const substr',
1059         setup   => 'my $x = "aaaabcd"',
1060         code    => 'index $x, "bcd"',
1061     },
1062     'func::index::long_const3aabcd_bcd' => {
1063         desc    => 'index of a long string against a 3 char const substr',
1064         setup   => 'my $x = "a" x 1000 . "bcd"',
1065         code    => 'index $x, "bcd"',
1066     },
1067     'func::index::long_const3ab_abc' => {
1068         desc    => 'index of a long string of "ab"s against a 3 char const substr "abc"',
1069         setup   => 'my $x = "ab" x 500',
1070         code    => 'index $x, "abc"',
1071     },
1072     'func::index::long_const3bc_abc' => {
1073         desc    => 'index of a long string of "bc"s against a 3 char const substr "abc"',
1074         setup   => 'my $x = "bc" x 500',
1075         code    => 'index $x, "abc"',
1076     },
1077     'func::index::utf8_position_1' => {
1078         desc    => 'index of a utf8 string, matching at position 1',
1079         setup   => 'my $x = "abc". chr(0x100); chop $x',
1080         code    => 'index $x, "b"',
1081     },
1082
1083
1084
1085     'func::sort::num' => {
1086         desc    => 'plain numeric sort',
1087         setup   => 'my (@a, @b); @a = reverse 1..10;',
1088         code    => '@b = sort { $a <=> $b } @a',
1089     },
1090     'func::sort::num_block' => {
1091         desc    => 'codeblock numeric sort',
1092         setup   => 'my (@a, @b); @a = reverse 1..10;',
1093         code    => '@b = sort { $a + 1 <=> $b + 1 } @a',
1094     },
1095     'func::sort::num_fn' => {
1096         desc    => 'function numeric sort',
1097         setup   => 'sub f { $a + 1 <=> $b + 1 } my (@a, @b); @a = reverse 1..10;',
1098         code    => '@b = sort f @a',
1099     },
1100     'func::sort::str' => {
1101         desc    => 'plain string sort',
1102         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1103         code    => '@b = sort { $a cmp $b } @a',
1104     },
1105     'func::sort::str_block' => {
1106         desc    => 'codeblock string sort',
1107         setup   => 'my (@a, @b); @a = reverse "a".."j";',
1108         code    => '@b = sort { ($a . "") cmp ($b . "") } @a',
1109     },
1110     'func::sort::str_fn' => {
1111         desc    => 'function string sort',
1112         setup   => 'sub f { ($a . "") cmp ($b . "") } my (@a, @b); @a = reverse  "a".."j";',
1113         code    => '@b = sort f @a',
1114     },
1115
1116     'func::sort::num_inplace' => {
1117         desc    => 'plain numeric sort in-place',
1118         setup   => 'my @a = reverse 1..10;',
1119         code    => '@a = sort { $a <=> $b } @a',
1120     },
1121     'func::sort::num_block_inplace' => {
1122         desc    => 'codeblock numeric sort in-place',
1123         setup   => 'my @a = reverse 1..10;',
1124         code    => '@a = sort { $a + 1 <=> $b + 1 } @a',
1125     },
1126     'func::sort::num_fn_inplace' => {
1127         desc    => 'function numeric sort in-place',
1128         setup   => 'sub f { $a + 1 <=> $b + 1 } my @a = reverse 1..10;',
1129         code    => '@a = sort f @a',
1130     },
1131     'func::sort::str_inplace' => {
1132         desc    => 'plain string sort in-place',
1133         setup   => 'my @a = reverse "a".."j";',
1134         code    => '@a = sort { $a cmp $b } @a',
1135     },
1136     'func::sort::str_block_inplace' => {
1137         desc    => 'codeblock string sort in-place',
1138         setup   => 'my @a = reverse "a".."j";',
1139         code    => '@a = sort { ($a . "") cmp ($b . "") } @a',
1140     },
1141     'func::sort::str_fn_inplace' => {
1142         desc    => 'function string sort in-place',
1143         setup   => 'sub f { ($a . "") cmp ($b . "") } my @a = reverse  "a".."j";',
1144         code    => '@a = sort f @a',
1145     },
1146
1147
1148     'func::split::vars' => {
1149         desc    => 'split into two lexical vars',
1150         setup   => 'my $s = "abc:def";',
1151         code    => 'my ($x, $y) = split /:/, $s, 2;',
1152     },
1153
1154     'func::split::array' => {
1155         desc    => 'split into a lexical array',
1156         setup   => 'my @a; my $s = "abc:def";',
1157         code    => '@a = split /:/, $s, 2;',
1158     },
1159     'func::split::myarray' => {
1160         desc    => 'split into a lexical array declared in the assign',
1161         setup   => 'my $s = "abc:def";',
1162         code    => 'my @a = split /:/, $s, 2;',
1163     },
1164     'func::split::arrayexpr' => {
1165         desc    => 'split into an @{$expr} ',
1166         setup   => 'my $s = "abc:def"; my $r = []',
1167         code    => '@$r = split /:/, $s, 2;',
1168     },
1169     'func::split::arraylist' => {
1170         desc    => 'split into an array with extra arg',
1171         setup   => 'my @a; my $s = "abc:def";',
1172         code    => '@a = (split(/:/, $s, 2), 1);',
1173     },
1174
1175
1176     'loop::block' => {
1177         desc    => 'empty basic loop',
1178         setup   => '',
1179         code    => '{1;}',
1180     },
1181
1182     'loop::do' => {
1183         desc    => 'basic do block',
1184         setup   => 'my $x; my $y = 2;',
1185         code    => '$x = do {1; $y}', # the ';' stops the do being optimised
1186     },
1187
1188     'loop::for::my_range1' => {
1189         desc    => 'empty for loop with my var and 1 integer range',
1190         setup   => '',
1191         code    => 'for my $x (1..1) {}',
1192     },
1193     'loop::for::lex_range1' => {
1194         desc    => 'empty for loop with lexical var and 1 integer range',
1195         setup   => 'my $x;',
1196         code    => 'for $x (1..1) {}',
1197     },
1198     'loop::for::pkg_range1' => {
1199         desc    => 'empty for loop with package var and 1 integer range',
1200         setup   => '$x = 1;',
1201         code    => 'for $x (1..1) {}',
1202     },
1203     'loop::for::defsv_range1' => {
1204         desc    => 'empty for loop with $_ and integer 1 range',
1205         setup   => ';',
1206         code    => 'for (1..1) {}',
1207     },
1208     'loop::for::my_range4' => {
1209         desc    => 'empty for loop with my var and 4 integer range',
1210         setup   => '',
1211         code    => 'for my $x (1..4) {}',
1212     },
1213     'loop::for::lex_range4' => {
1214         desc    => 'empty for loop with lexical var and 4 integer range',
1215         setup   => 'my $x;',
1216         code    => 'for $x (1..4) {}',
1217     },
1218     'loop::for::pkg_range4' => {
1219         desc    => 'empty for loop with package var and 4 integer range',
1220         setup   => '$x = 1;',
1221         code    => 'for $x (1..4) {}',
1222     },
1223     'loop::for::defsv_range4' => {
1224         desc    => 'empty for loop with $_ and integer 4 range',
1225         setup   => ';',
1226         code    => 'for (1..4) {}',
1227     },
1228
1229     'loop::for::my_list1' => {
1230         desc    => 'empty for loop with my var and 1 integer list',
1231         setup   => '',
1232         code    => 'for my $x (1) {}',
1233     },
1234     'loop::for::lex_list1' => {
1235         desc    => 'empty for loop with lexical var and 1 integer list',
1236         setup   => 'my $x;',
1237         code    => 'for $x (1) {}',
1238     },
1239     'loop::for::pkg_list1' => {
1240         desc    => 'empty for loop with package var and 1 integer list',
1241         setup   => '$x = 1;',
1242         code    => 'for $x (1) {}',
1243     },
1244     'loop::for::defsv_list1' => {
1245         desc    => 'empty for loop with $_ and integer 1 list',
1246         setup   => ';',
1247         code    => 'for (1) {}',
1248     },
1249     'loop::for::my_list4' => {
1250         desc    => 'empty for loop with my var and 4 integer list',
1251         setup   => '',
1252         code    => 'for my $x (1,2,3,4) {}',
1253     },
1254     'loop::for::lex_list4' => {
1255         desc    => 'empty for loop with lexical var and 4 integer list',
1256         setup   => 'my $x;',
1257         code    => 'for $x (1,2,3,4) {}',
1258     },
1259     'loop::for::pkg_list4' => {
1260         desc    => 'empty for loop with package var and 4 integer list',
1261         setup   => '$x = 1;',
1262         code    => 'for $x (1,2,3,4) {}',
1263     },
1264     'loop::for::defsv_list4' => {
1265         desc    => 'empty for loop with $_ and integer 4 list',
1266         setup   => '',
1267         code    => 'for (1,2,3,4) {}',
1268     },
1269
1270     'loop::for::my_array1' => {
1271         desc    => 'empty for loop with my var and 1 integer array',
1272         setup   => 'my @a = (1);',
1273         code    => 'for my $x (@a) {}',
1274     },
1275     'loop::for::lex_array1' => {
1276         desc    => 'empty for loop with lexical var and 1 integer array',
1277         setup   => 'my $x; my @a = (1);',
1278         code    => 'for $x (@a) {}',
1279     },
1280     'loop::for::pkg_array1' => {
1281         desc    => 'empty for loop with package var and 1 integer array',
1282         setup   => '$x = 1; my @a = (1);',
1283         code    => 'for $x (@a) {}',
1284     },
1285     'loop::for::defsv_array1' => {
1286         desc    => 'empty for loop with $_ and integer 1 array',
1287         setup   => 'my @a = (@a);',
1288         code    => 'for (1) {}',
1289     },
1290     'loop::for::my_array4' => {
1291         desc    => 'empty for loop with my var and 4 integer array',
1292         setup   => 'my @a = (1..4);',
1293         code    => 'for my $x (@a) {}',
1294     },
1295     'loop::for::lex_array4' => {
1296         desc    => 'empty for loop with lexical var and 4 integer array',
1297         setup   => 'my $x; my @a = (1..4);',
1298         code    => 'for $x (@a) {}',
1299     },
1300     'loop::for::pkg_array4' => {
1301         desc    => 'empty for loop with package var and 4 integer array',
1302         setup   => '$x = 1; my @a = (1..4);',
1303         code    => 'for $x (@a) {}',
1304     },
1305     'loop::for::defsv_array4' => {
1306         desc    => 'empty for loop with $_ and integer 4 array',
1307         setup   => 'my @a = (1..4);',
1308         code    => 'for (@a) {}',
1309     },
1310
1311     'loop::for::next4' => {
1312         desc    => 'for loop containing only next with my var and integer 4 array',
1313         setup   => 'my @a = (1..4);',
1314         code    => 'for my $x (@a) {next}',
1315     },
1316
1317     'loop::grep::expr_3int' => {
1318         desc    => 'grep $_ > 0, 1,2,3',
1319         setup   => 'my @a',
1320         code    => '@a = grep $_ > 0, 1,2,3',
1321     },
1322
1323     'loop::grep::block_3int' => {
1324         desc    => 'grep { 1; $_ > 0} 1,2,3',
1325         setup   => 'my @a',
1326         code    => '@a = grep { 1; $_ > 0} 1,2,3',
1327     },
1328
1329     'loop::map::expr_3int' => {
1330         desc    => 'map $_+1, 1,2,3',
1331         setup   => 'my @a',
1332         code    => '@a = map $_+1, 1,2,3',
1333     },
1334
1335     'loop::map::block_3int' => {
1336         desc    => 'map { 1; $_+1} 1,2,3',
1337         setup   => 'my @a',
1338         code    => '@a = map { 1; $_+1} 1,2,3',
1339     },
1340
1341     'loop::while::i1' => {
1342         desc    => 'empty while loop 1 iteration',
1343         setup   => 'my $i = 0;',
1344         code    => 'while (++$i % 2) {}',
1345     },
1346     'loop::while::i4' => {
1347         desc    => 'empty while loop 4 iterations',
1348         setup   => 'my $i = 0;',
1349         code    => 'while (++$i % 4) {}',
1350     },
1351
1352
1353     'regex::anyof_plus::anchored' => {
1354         desc    => '/^[acgt]+/',
1355         setup   => '$_ = "a" x 100;',
1356         code    => '/^[acgt]+/',
1357     },
1358     'regex::anyof_plus::floating' => {
1359         desc    => '/[acgt]+where match starts at position 0 for 100 chars/',
1360         setup   => '$_ = "a" x 100;',
1361         code    => '/[acgt]+/',
1362     },
1363     'regex::anyof_plus::floating_away' => {
1364         desc    => '/[acgt]+/ where match starts at position 100 for 100 chars',
1365         setup   => '$_ = ("0" x 100) . ("a" x 100);',
1366         code    => '/[acgt]+/',
1367     },
1368 ];