Have you ever wondered how much difference Perl coding styles make to performance? Perl has lots of ways to do the same thing, and some are more readable/maintainable, but are slower or consume more memory...or is it the other way around? We'll look at Perl syntax and see what performs better or worse and why. Maybe your favorite syntax is an awesome efficient race horse, maybe it's a pig, or maybe it makes no difference. Come see your dreams shattered, hopes dashed, or realize how awesome your syntax choices really are!

1. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 1
Perl Optimization Tidbits
Daina Pettit
Bluehost/EIG
dpettit@bluehost.com
daina@xmission.com

2. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 2
Perl Optimization Tidbits
Daina Pettit
Bluehost/EIG
dpettit@bluehost.com
daina@xmission.com

3. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 3
Purpose
● Look at performance differences of equivalent code
● What is faster and/or smaller
● Does it make a difference?

4. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 4
Other Considerations
● Readability
● Maintainability

5. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 5
Focus
1. Language constructs
2. Algorithmic Tweaks (if time)
Such as slurp vs. record-based processing
$x++;
vs.
++$x;

6. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 6
Assumptions
Choices matter, right?
Can it make a difference?

7. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 7
Assumptions
Choices matter, right?
Can it make a difference?
Testing tools will give us good enough answers.
Results will be comparative, not absolute.
Performance comparison numbers are a bit squishy.

8. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 8
Performance Environment
● CentOS Linux 6.7
● 16G RAM
● 64-bit quad core i5-3210M Intel CPU @ 2.50GHz
● Perl version 5.22.2 (April 2016)

9. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 9
Performance Environment
● CentOS Linux 6.7
● 16G RAM
● 64-bit quad core i5-3210M Intel CPU @ 2.50GHz
● Perl version 5.22.2 (April 2016)
YMMV depending on perl version, OS, hardware, and configuration.
Performance measured by NYTProf and time

10. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 10
Methodology
Write lines of code as simple as possible.
Execute code hundreds of thousands or millions of times.
Analyze results with NYTProf
Look for problems in results.
Adjust.
Repeat.

11. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 11
Example
Is pre-increment faster than post-increment?
foreach (1..1_000_000) {
$x++;
++$y;
}

12. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 12
Example
NYTProf results html view
Analyze, adjust, repeat, draw conclusions

13. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 13
Case 1: Auto Increment/Decrement
Pre/post increment/decrement integers and strings
$x++
++$x
$x­­
­­$x
$str++
++$str

14. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 14
Case 1: Auto Increment/Decrement—Results
Pre/post increment/decrement integers and strings
Alphabetic post-increment is twice as slow as numeric!
$x++
++$x – Numeric pre­increment faster by 3.7%
$x­­
­­$x – Numeric pre­decrement faster by 2.2%
$str++ – Alphabetic post­increment twice as
fast as pre­increment
++$str

15. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 15
Case 2: /xms or not
RE switches: /xms, recommended in PBP
m/.../xms
m/.../

16. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 16
Case 2: /xms or not—Results
$x++
++$x – Numeric pre­increment faster by 3.7%
$x­­
­­$x – Numeric pre­decrement faster by 2.2%
$str++ – Alphabetic post­increment twice as
fast as pre­increment
++$str
m/.../xms – 3% slower and more confusing
m/.../
Do not recommend.

17. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 17
Case 3: for vs. foreach
for and foreach are supposed to be synonyms.
foreach ( @x ) { }
for ( @x ) { }

18. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 18
Case 3: for vs. foreach—Results
for and foreach are supposed to be synonyms.
Very close, but foreach may be slightly faster.
foreach ( @x ) { }
for ( @x ) { }

19. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 19
Case 4: for vs. foreach Part 2
for and foreach with my looping variable.
foreach my $y ( @x ) { }
for my $y ( @x ) { }

20. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 20
Case 4: for vs. foreach Part 2—Results
for and foreach with my looping variable.
With my, speed is near identical­­foreach less than 1% faster.
foreach my $y ( @x ) { }
for my $y ( @x ) { }

21. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 21
Case 5: for vs. foreach vs. map
foreach ( @x ) { }
for ( @x ) { }
map { } @x;

22. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 22
Case 5: for vs. foreach vs. map—Results
map is 30% slower. Why?
foreach ( @x ) { }
for ( @x ) { }
map { } @x;

23. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 23
Why is map slower?
● map is best for creating new lists, so it builds a new list.
● foreach/for are best for transforming a list.
@words = map { split } @lines;
foreach ( @lines ) {
$_ = uc;
}

24. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 24
Case 6: not vs. !
not $x
! $x

25. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 25
Case 6: not vs. !—Results
No significant difference.
not $x
! $x

26. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 26
Case 7: and vs. &&
$x and $y
$x && $y

27. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 27
Case 7: and vs. &&—Results
&& is 20% slower than and!
$x and $y
$x && $y

28. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 28
Case 8: or vs. ||
$x or $y
$x || $y

29. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 29
Case 8: or vs. ||—Results
or is 30% faster than ||!
$x or $y
$x || $y

30. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 30
Case 8: or vs. ||—More Results
or is 30% faster than ||!
or is about twice as fast as and!
$x or $y
$x || $y

31. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 31
Case 9: String Interpolation
$x = $y;
$x = "$y";

32. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 32
Case 9: String Interpolation—Results
With double quoted string is 10% faster!
$x = $y;
$x = "$y";

33. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 33
Case 10: Single vs. Double Quotes
$x = 'abc';
$x = "abc";

34. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 34
Case 10: Single vs. Double Quotes—Results
Double quoted string is almost always significantly faster!
$x = 'abc';
$x = "abc";

35. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 35
Case 11: Variable Interpolation
$x = "abc$y";
$x = "abc${y}";

36. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 36
Case 11: Variable Interpolation—Results
Using {} is faster by about 10%.
$x = "abc$y";
$x = "abc${y}";

37. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 37
Case 12: Order of Concatenation
$x = "abc" . $y;
$x = $y . "abc";

38. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 38
Case 12: Order of Concatenation—Results
String on left is almost always significantly faster.
$x = "abc" . $y;
$x = $y . "abc";

39. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 39
Case 13: Scope
Creating scope with code block.
{ $x = 5; }
$y = 3;

40. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 40
Case 13: Scope—Results
Creating scope with code block.
Scope costs 300%.
{ $x = 5; }
$y = 3;

41. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 41
Case 14: Scope with my
Creating scope with code block and my.
{ my $x = 5; }
my $y = 3;

42. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 42
Case 14: Scope with my—Results
Creating scope with code block and my.
Scope limiting version of my costs 200%.
{ my $x = 5; }
my $y = 3;

43. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 43
Case 15: Scope with local
Creating scope with code block and local.
{ local $x = 5; }
local $y = 3;

44. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 44
Case 15: Scope with local—Results
Creating scope with code block and local.
Scope limiting version of local costs about 20%.
local costs about 20% more than my.
{ local $x = 5; }
local $y = 3;

45. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 45
Case 16: More Scope with my
Creating scope, masking existing variable with my.
my $x = 2;
{ my $x = 5; }

46. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 46
Case 16: More Scope with my—Results
Creating scope, masking existing variable with my.
Masking a variable with my is about 15% slower.
my $x = 2;
{ my $x = 5; }

47. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 47
Case 17: Subroutine Arguments
Getting arguments in various ways.
my $x = shift;
my $x = $_[0];
my ( $x ) = @_;

48. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 48
Case 17: Subroutine Arguments—Results
Getting arguments in various ways.
my $x = shift; Second Place (15% slower)
my $x = $_[0]; Fastest
my ( $x ) = @_; Slowest (50% slower)

49. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 49
Case 18: Control Structure
Standard if statement equivalents
if ( $x ) { }
$x && do { }

50. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 50
Case 18: Control Structure—Results
Standard if statement equivalents
Identical performance
if ( $x ) { }
$x && do { }

51. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 51
Case 18: Control Structure—Results
Standard if statement equivalents
Identical performance
Why would you use one over the other?
if ( $x ) { }
$x && do { }

52. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 52
Case 19: Control Structure Part 2
Standard if else statement equivalents
if ( $x ) { } else { }
$x && do { } || do { }

53. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 53
Case 19: Control Structure Part 2—Results
Standard if else statement equivalents
do form is 40% faster
if ( $x ) { } else { }
$x && do { } || do { }

54. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 54
Case 19: Control Structure Part 2—Results
Standard if else statement equivalents
do form is 40% faster
Why would you use one over the other?
if ( $x ) { } else { }
$x && do { } || do { }

55. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 55
Case 20: return
return or not?
sub x { return $_[0]; }
sub x { $_[0]; }

56. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 56
Case 20: return—Results
return or not?
return is about 10% slower.
sub x { return $_[0]; }
sub x { $_[0]; }

57. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 57
Case 21: Print a list
print $x, $y;
print $x;
print $y;

58. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 58
Case 21: Print a list—Results
print a list is about 20% faster than done separately.
print $x, $y;
print $x;
print $y;

59. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 59
Case 22: Print With or Without join
Which print is faster?
print join '­', @x;
$, = '­';
print @x;

60. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 60
Case 22: Print With or Without join—Results
Which print is faster?
join form is slightly faster, but not consistently faster.
print join '­', @x;
$, = '­';
print @x;

61. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 61
Case 23: Array vs. Hash Speed
Which is faster?
$x[$y]
$x{$y}

62. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 62
Case 23: Array vs. Hash Speed—Results
Which is faster?
Hash access is about 50% slower than array access.
$x[$y]
$x{$y}

63. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 63
Slurping to Optimize Input
Easy in Perl
Minimize disc cache
No difference if record count is small
Probably not a good idea if your file is bigger than your RAM
@x = <>;
undef $/;
$x = <>;

64. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 64
Weaknesses in Testing
1. NYTProf tends to over­allocate time to the last statement in
a block
2. Almost certainly there are other unknown quirks in NYTProf
3. Invisible internal perl optimizations
4. Statement order matters
5. Performance absolutes are hard to quantify. Comparisons
are best.

65. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 65
Summary
Most of this doesn't really matter!

66. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 66
Conclusion
1. Features like variable scoping cost!
2. Focus on the human cost—maintenance and readability
3. In almost all cases nothing else matters.
4. Biggest optimization gains are almost always due to
algorithmic changes, not stylistic choices.
5. However, if you really do need to optimize, now you can
make informed choices!

67. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 67
Further Information
● perldoc Devel::NYTProf
● perldoc Benchmark
● For optimization of sorting and powerful functions map and grep
see May 2014 OpenWest presentation – Streamlining and
simplifying your Perl code using Map, Grep, and Sort on
YouTube.

68. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 68
Q&A
Comments?
Questions?

69. Copyright 2017 Daina Pettit
Perl Optimization Tidbits – slide 69
Acknowledgments
Many thanks to
● Larry Wall
● Bluehost/EIG
● Tim Bunce