{"id":1645,"date":"2013-06-25T18:24:18","date_gmt":"2013-06-25T12:39:18","guid":{"rendered":"https:\/\/www.sparksupport.com\/blog\/?p=1645"},"modified":"2024-06-24T10:34:30","modified_gmt":"2024-06-24T10:34:30","slug":"perl-application-tuning","status":"publish","type":"post","link":"https:\/\/sparksupport.com\/blog\/perl-application-tuning\/","title":{"rendered":"Perl Application Tuning"},"content":{"rendered":"

Have you ever thought about performance Perl<\/a> Application Tuning ? Read-on to get a starting !
\nIdentifying Performance Issues<\/strong><\/span>
\nThe first task at hand in improving the performance of an application is to determine what parts of the application are not performing as well as they should. You need to find things that are actually slow. It’s no good wasting your effort on things that are already fast.<\/p>\n

In this case I used two techniques to identify potential performance problems, code review and profiling.<\/p>\n

A performance code review is the process of reading through the code looking for suspicious operations. The advantage of code review is the reviewer can observe the flow of data through the application. Understanding the flow of data through the application helps identify any control loops that can be eliminated<\/p>\n

Application profiling is the process of monitoring the execution of an application to determine where the most time is spent and how frequently operations are performed. In this case, I used a Perl package called Benchmark::Timer. This package provides functions that I use to mark the beginning and end of interesting sections of code. Each of these marked sections of code are identified by a label. When the program is run and a marked section is entered, the time taken within that marked section is recorded.<\/p>\n

Below is an example of\u00a0 using Benchmark<\/p>\n

#!\/usr\/bin\/perl
\nuse Benchmark;
\n$time0 = Benchmark->new;
\n# your perl code here
\n$time1 = Benchmark->new;
\n$diffrence = timediff($time1, $time0);
\nprint “the code took:”,timestr($difference);<\/p><\/blockquote>\n

Refactoring<\/strong><\/span><\/p>\n

Below is some methods for refactoring Perl Application tuning code.<\/p>\n

Use references<\/p>\n

If you work with large arrays or hashes and use them as arguments to functions, use a reference instead of the variable directly. By using a reference, you tell the function to point to the information. Without a reference, you copy the entire array or hash onto the function call stack, and then copy it again in the function. this will increase the performance by avoiding copying the entire contents of the data array in to the function References also save memory and simplify your programming.<\/p>\n

Using short circuit logic<\/p>\n

Please see sample code below. Using many if statements can be incredibly time consuming.<\/p>\n

If ($x > 0)
\n{
\n$value = $x;
\n}
\nelsif ($y > 0)
\n{
\n$value = $ y;
\n}
\nelse
\n{
\n$value = $default;
\n}<\/p><\/blockquote>\n

Aside from the waste of space in terms of sheer content, there are a couple of problems with this structure. From a programming perspective, it has the issue that it never checks if any of the variables have a valid value, a fact that would be highlighted if warnings were switched on. Second, it has to check each option until it gets to the one it wants, which is wasteful, as comparison operations (particularly on strings) are time consuming. Both problems can be solved by using short circuit logic.<\/p>\n

If you use the logical || operator, Perl will use the first true value it comes across, in order, from left to right. The moment it finds a valid value, it doesn’t bother processing any of the other values. In addition, because Perl is looking for a true value, it also ignores undefined values without complaining about them. So we can rewrite the above into a single line:<\/p>\n

$value = $x || $y || $default;<\/p><\/blockquote>\n

If $x is a true value, Perl doesn’t even look at the other variables. If $x is false, then Perl checks the value of $y and so on until it gets to the last value, which is always used, whether it’s true or not.<\/p>\n

String handling<\/p>\n

If you are using static strings in your application, remember to use single quotes rather than doubles. Double quotes force Perl to look for a potential interpolation of information, which adds to the overhead of printing out the string:<\/p>\n

print ‘A string’,’another string’,”\\n”;<\/p><\/blockquote>\n

I’ve also used commas to separate arguments rather than using a period to concatenate the string first. This simplifies the process;print simply sends each argument to the output file. Concatenation would concatenate the string and print it as one argument.<\/p>\n

Concatenating a string<\/p>\n

Example 1<\/p>\n

my $str = ‘haihelloworld’;
\nmy $concat = ‘ ‘;
\nforeach my $c (1..10000)
\n{
\n$concat .= $str;
\n}<\/p><\/blockquote>\n

Example 2<\/p>\n

my $str = ‘haihelloworld’;
\nmy @concat;
\nforeach my $c (1..10000)
\n{
\npush @concat, $str;
\n}
\nmy $concat = join( ‘ ‘, @concat);<\/p><\/blockquote>\n

Running Example2 requires more time than running Example 1. Both generate a string, so what’s taking up the time? Conventional wisdom (including that of the Perl team) would say that concatenating a string is a time-expensive process, because we have to extend the memory allocation for the variable and then copy the string and its addition into the new variable. Conversely, adding a string to an array should be relatively easy. We also have the added problem of duplicating the string concatenation using join(), which adds an extra second.<\/p>\n

Use AutoLoader<\/strong><\/span><\/p>\n

If you’re writing modules use the AutoSplit and AutoLoader modules to make Perl Application tuning only load the parts of your
\nmodule that are actually being used by a particular script. You get two gains – you don’t waste CPU at start up
\nloading the parts of your module that aren’t used, and you don’t waste the RAM holding the the structures that
\nperl generates when it has compiled code. So your modules load more quickly, and use less RAM.<\/p>\n

It’s easy to use by just changing your modules from the format shown in Example 3 to that shown in Example 4,
\nand then making sure to use AutoSplit to create the loading functions you need. Note that you don’t need to
\nuse Exporter any more; AutoLoader handles the loading of individual functions automatically without you have to
\nexplicitly list them<\/p>\n

Example 3<\/p>\n

Package MyModule;
\nuse OtherModule;
\nrequire ‘Exporter’;
\n@EXPORT = qw\/MsSub\/;
\nsub MySub
\n{
\n#function code here
\n}
\n1;<\/p><\/blockquote>\n

Example 4<\/p>\n

package MyModule;
\nuse OtherModule;
\nuse AutoLoader ‘AUTOLOAD’;
\n1;<\/p>\n

__END__
\nsub MySub
\n{
\n# function code here
\n}<\/p><\/blockquote>\n

reference : Wikipedia<\/a><\/div>\n