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