Become a fan of Slashdot on Facebook

 



Forgot your password?
typodupeerror
×
Perl Programming

Optimizing Perl 68

An anonymous reader writes "Perl is an incredibly flexible language, but its ease of use can lead to some sloppy and lazy programming habits. We're all guilty of them, but there are some quick steps you can take to improve the performance of your Perl applications. This article looks at the key areas of optimization, which solutions work and which don't, and how to continue to build and extend your applications with optimization and speed in mind."
This discussion has been archived. No new comments can be posted.

Optimizing Perl

Comments Filter:
  • Error 400 (Score:2, Funny)

    by hattmoward ( 695554 )
    Proxy Error: Unable to connect to remote host "ltsgnd001k.sby.ibm.com" or host not responding - URL "http://ltsgnd001k.sby.ibm.com/developerworks/libr ary/l-optperl.html?ca=dgr-lnxw01OptPerl", errno: 79

    Does this mean you can't optimize Perl? =D

    Disclaimer: I use Perl almost exclusively for programming.

    • "Disclaimer: I use Perl almost exclusively for programming."

      Good, it's useless for babysitting, or cooking, for example.

      FP.
  • by torpor ( 458 ) <ibisumNO@SPAMgmail.com> on Friday October 22, 2004 @10:01AM (#10598138) Homepage Journal
    rm -rf /usr/bin/perl

    { Just Use Python! :) }
    • Why would you need -r if /usr/bin/perl is one file, maybe a symlink? -f is possible too, but unlikely.
    • It's a little ironic that you wrapped "Just Use Python! :)" in curly braces, isn't it?
    • They said optimizing.
      You are aware that Python sucks when it comes to speed?
      You should look at the python-dev mailing list about how many times people mentioned that Python is slow, especially for regular expressions.
      One time someone suggested openning a perl process from within Python.
      So think twice before suggesting slow languages.

      NOTE: I personally hate Python, so I might not be too objective, but Python being slow compared to Perl is objective!
    • I don't get hy people act like Python is a perl killer. Python is an interpreted OO language with limited string handling built into the main language and a unwieldly large standard library. Seems more like a Java competitor than perl.
      • why should a language be all about string handling? thats what good libs are for.

        this article starts out with the 'some people program in Perl and use terrible habits' point. the problem is, Perl allows you into this bad habit territory, by design of the language.

        string handling is just one use for a language. python has plenty of superb string handling libs. its also very difficult to get into the same 'bad habit' territory that you can get into with Perl..

        my original post was to make the point that
        • True, but then you can get the same libraries for C, C++, Java, etc. Python still doesn't seem to try and fill the same gap than perl does- its much more of a Java competitor, without the applet nonsense.
          • i've never though of Python as a replacement for Java. I've thought of it as a replacement for Perl, many, many, many times over, and have used it in that capacity quite well, too.

            That said, I'm learning Ruby these days. Ruby continues to impress me .. I found a Ruby script to do administration on HTML files which nearly brought tears to my eyes, it was so well-written, so fun to understand, and it worked so damned well.
  • by FooAtWFU ( 699187 ) on Friday October 22, 2004 @10:05AM (#10598187) Homepage
    The first rule of program optimization: Don't do it.
    The second rule or program optimization (FOR EXPERTS ONLY!): Don't do it yet.

    -- fortune

    • by Smallpond ( 221300 ) on Friday October 22, 2004 @12:20PM (#10599693) Homepage Journal
      +1 insightful.

      Look at his first example, which is concatentating 1 million strings. His "bad" time is 5.2 seconds and the good time is 1.7. Who cares? Nobody uses perl to do high-performance computing. Imagine you are extracting 1M strings from a database and doing something with them. Would you care about a 3 second difference?

      Its OK to write good code, but its better to make your code clear and not dependent on clever tricks.
      • by Anonymous Coward
        Unfortunately, perl is now used in bioinformatics an awful lot. Genetic analyses are (rather frighteningly) regularly carried out in perl. While any computer scientist would point out that lisp or, hell, even python, would be more appropriate, yes, that 3 second difference probably does matter to some people.
      • I'd care about a 3 second difference if I was sitting waiting for an answer, yes.

        Atitiudes like this is a large part of why software sucks so badly. Hardware enjoys a huge speed increase every year, but my computer can't do any more because software has slowed by about that much. Newsflash- I don't care if new computers are faster, the speed of my existing hardware didn't increase.

        Performance matters. And just like security, it can't be an afterthought. You need to design for efficiency, trying to sh
        • Performance matters. And just like security, it can't be an afterthought.

          Performance always matters. A program which computes the monthly payrolls is useless if it takes three months to run. However...

          1. Performance may not be an issue in your particular program. If it's good enough, it's good enough.
          2. "Performance" may not mean what you think it means. For one application, throughput (i.e. the amount of work you can do right before overload) is the most important consideration. For others, scalabilit
          • Brilliant post.

            I'm a speed freak, everything I do needs to be fast (I work with computational number theory), but I code almost entirely in C, and only very very rarely resort to assembly language. I often end up with faster code than those that are 100% assembly language, due to investment in your #3 and #6.

            And all of my house-keeping tasks (management of lists of candidates, or factors, or whatever) I code in Perl, because of your #1 (and #3).

            FP.
  • by justanyone ( 308934 ) on Friday October 22, 2004 @10:07AM (#10598210) Homepage Journal
    I know, many people means many styles.
    Here's my style guide, something I developed using Perl for over 5 years now.

    Pardon the length, it's unavoidable.

    Perl Coding Conventions and Style Guide
    By Kevin J. Rice, Kevin@justanyone.com

    General conventions:

    Read the Perl style guide (http://theoryx5.uwinnipeg.ca/CPAN/perl/pod/perlst yle.html), and follow the conventions therein, especially the following:
    4-column indent
    Blank lines between chunks that do different things.
    Use mnemonic variables- the names must mean something useful. No one character names!
    Variable naming conventions:
    $ALL_CAPS_HERE constants only (beware clashes with perl vars!);
    $Some_Caps_Here package-wide global/static (also prefix 'gv_', see below);
    $no_caps_here function scope my() or local() variables;
    Be consistent.
    Be nice.

    Specific Coding Practices:

    1. Always do a 'use strict;' at the beginning of every module and script. This catches both subtle errors and bad coding practices.

    2. Programs should pass 'use warnings;' with a minimum of warnings before going into production. Note: turning off warnings in production is sometimes required for security or stability purposes. Solve root cause for all warnings if possible; don't just eliminate immediate cause.

    3. Turn on Taint checking for all cgi / web enabled scripts. Invoke with "perl -T" or "#!/usr/bin/perl -T".

    4. Use spaces for indenting, not tab characters. No file should contain any tab characters. These display differently in various terminals/editors, and mixing spaces and tabs makes code very messy. Most modern editors can be set to automatically insert spaces in place of tabs.

    5. Each subroutine should perform one distinct task. Feel free to break down lengthy (i.e., more than 1-2 screenfuls of code) subs. This means almost all subroutines should be 120 lines or less; longer ones should be justified in code review.

    6. Code blocks, when more than 1 or 2 lines, should have the block { } at the same indentation level to aid visual clarity of where that block starts/stops. Example:

    if ($condition == $value)
    {
    $another_var++;
    $two = $three + 12;
    }
    else
    {
    $four = $pi * 13;
    }

    7. Fully parenthesize stuff like "if ($a >= 5 || $b > 4)" into "if (($a >= 5) || ($b > 4))" so the user has no need to know/get wrong the order-of-operations. This includes one line conditionals like, "if (a) {}" - don't do: "if a {}".

    8. Evals: Always use evals when doing system calls. If otherwise using them, always comment/explain why. If you know something might 'die', explain it specifically, since it probably isn't obvious.

    9. Explicitly 'return' values at the end of every sub. Don't EVER use the last statement's value as a default return value; someone modifying the code later might not know you're depending on that value.

    10. All modules must explicitly end with '1;' to provide a return value for the module.

    11. Minimize the use of map() due to its confusing nature.

    12. Use parentheses around all function calls, such as sort($a, $b) instead of "sort $a $b;" to make it obvious a function call is occurring. Prefer not to use the Perl subroutine operator, as in "&subroutinename($arg1, $arg2);" just do "subroutinename($arg1, $arg2);".

    13. Don't use the 'unless' verb. Instead of, "unless($foo) {...}", code: "if (!$foo) {...}". The 'unless' verb is plenty confusing due to its uniqueness to Perl.

    14. Modules and scripts, when over 200 or so lines, should have a logMessage() subroutine that allows for various levels of logging (0=silent, 1=minimal, 4=normal, 8=verbose): logMessage(1, "message");

    15. Use a main() sub for all scripts, and include an explicit exit with an exit code appropriate to the platform you're on. Do not

    • by hattmoward ( 695554 ) on Friday October 22, 2004 @10:14AM (#10598270)

      I usually put the CVS $Log: $ at the end of the script, after an __END__, and place a note about it at the top. You can also use the following snippet if you want to make your module's version equivalent to the CVS revision number: use vars qw($VERSION); $VERSION = ('$Revision: $ ' =~ /(\d+\.\d+)/)[0];

      • by Anonymous Coward
        Oops! I'm so used to <code> tags at Perl Monks...

        use vars qw($VERSION);
        $VERSION = ('$Revision: $ ' =~ /(\d+\.\d+)/)[0];
    • 4. I disagree. The tab is useful. The fact that they display differently in various terminals/editors is a FEATURE! But I agree that mixing spaces and tabs is a bad idea.

      6. bullshit. That's personal taste.

      13. utter bullshit. What's confusing about 'unless'? It may be unique to perl, but it's a pretty obvious english word.

      14. bah

      16. good! good that you don't prohibit gotos

      18. bullshit. The $_ variable has a nice semantic value. Of course it should be used only in small blocks.

      21. hmm.. Sometimes it's n
      • Re:some comments (Score:5, Insightful)

        by justanyone ( 308934 ) on Friday October 22, 2004 @12:52PM (#10600091) Homepage Journal
        4. Tabs: Tab is a nasty character that is not visibly different from x number of spaces. Lots of people like tabs. That's fine. Lots of people don't. That's fine, too. But, when 2 people work on the same code, bad stuff happens. Spaces ALWAYS get mixed in. This is bad. The easiest method to elim this prob is No Tab Chars. This can get religious, but BADLY ALIGNED CODE LEADS TO CODING ERRORS! This is a frequent mistake and costs time (and therefore money and anger).

        6. The "bullshit... personal taste" aspect of brace alignment is both true and misleading. Really, it doesn't matter which way you do it, as long as you're consistent. But, with multiple people working on the same code, consistency is difficult. I've always done it with left brace on the left margin so I could easily see what lined up where. If your rule is opposite, fine, but USE ONLY ONE and code looks much nicer.

        13. UNLESS (pardon my french) = stronzino (a little piece of shit). It's in the language to assist removal of a single ! 'not'. This can really confuse people. I'm not the smartest guy, nor the dumbest, but sometimes I see it and just go, "huh?". I'm not used to it. Neither have been many other Perl coders I know when we've spoken about it.

        14. I take it by "Bah" you don't like scripts to log their actions. I've fought this recently with a 'know-it-all' type who wanted to build something fancy to do logging "when I get around to it". Yuck. Keep it simple, log what's going on so you can trace it later. Simple text files with "just did this, value=12" can help tremendously in debugging production problems. Users never know what they did; error messages never can contain enough info about what happened before.

        16. GOTOs are evil. I admit to some brainwashing by CS profs on this, but have dealt with enough spaghetti code to agree with it. Yes, there are times when it's good. But, in my last 100,000 lines of Perl, I haven't had to use it yet. So, it must not be vital. My goal is simplicity of code, not speed, since who cares about speed most of the time anyway, unless it's really bad, in which case there's probably somethign you're doing wrong otherwise.

        18. $_ is valuable only until you need to know what's in it. Then, you need a real variable name. You also may need that var to stick around past the next function call. I say, use 'my $request = $_; ' or something to grab $_ and make it obvious.

        21. Declaring vars near use is good ONLY in subs. If you have:
        exit(main());
        sub main
        {
        do_jack($GV_DEF_ONE);
        }
        my $GV_DEF_ONE = 12;
        sub do_jack
        {
        ....
        }
        you'll get an error during parsing due to GV_DEF_ONE not being declared yet.

        Regardless, Global vars are hard enough to spot and should be rare, declare them all at the top of the module to make it bloody obvious you're using one.

        22. I can sometimes agree to my ($a, $b) = split(',',@inlist); but not disparate vars all crammed together on one line, it's not readable, the vars are hidden, not aligned and initialized, etc.

        29. Lines of hashes visually indicate end of file. I can always tell I have the last page of a printout when all my files end with 5 or so rows of hashes. Just convention and a good idea, not a hard-fast rule.
        • WTF???

          Lameness filter encountered.
          Your comment violated the "postercomment" compression filter. Try less whitespace and/or less repetition. Comment aborted.

          13. There are times the 'unless' fits right in. Like when the action will take place by default, but have some exception. Like

          print $dirname unless $dirname =~ /\A\.[\.]+\Z/;

          16. Spagheti code is evil, not goto. Since Perl have more flexible flow control, I don't remember to have used it yet, but when coding in C, sometimes I use goto to cleanly
        • Sorry, but if you think "unless" is confusing, then you're absolutely nuts.

          How is "unless" MORE confusing than "if not this is true?"

          die "Connection lost" unless $connection->ping;

          Thank God for unless.
      • The tab is useful. The fact that they display differently in various terminals/editors is a FEATURE!

        Please name an editor or terminal which doesn't treat TAB in the way God intended. Unless the user selects the option "I want my text files to be incompatible with all other tools in the known world". Which, granted, a surprising number of people do ...

        • MS-DOS/Windows edit.com doesn't! It converts tabs to spaces on load, and (maybe) converts (some) spaces to tabs on save. Of course, God probably doesn't intend for people to waste their time with edit.com in the first place.

    • 4. Use spaces for indenting, not tab characters. No file should contain any tab characters. These display differently in various terminals/editors, and mixing spaces and tabs makes code very messy. Most modern editors can be set to automatically insert spaces in place of tabs.

      I've never understood this one. Granted, mixing spaces and tabs makes for messy code, but there are two solutions to that: Use only spaces, or use only tabs.

      Why not tabs? They're easier to type when you're deeply nested, just hit

      • Doug:

        As I mentioned above in a reply to that post, the varying depth of tabs can really get you in trouble.

        My editor (http://ultraedit.com/ [ultraedit.com], when I hit the tab key, insert 4 spaces. Thus the ease of tabbing over to column 20 is indeed 4 keypresses. However, if my coworker does the same thing with his tab settings at 8, he hits tab twice and then puts in 4 spaces to align it. Ug. Or, hits tab 10 times if he's using a tabsize of 2. Yuck again.

        Emperically, you want a study that says that mixed use wast
        • My editor (http://ultraedit.com/, when I hit the tab key, insert 4 spaces.

          *THIS HITS THE NAIL ON THE HEAD*

          You've got it configured to *insert* spaces when you hit tab. I don't recall ultraedit doing that by default (haven't used it in a few years tho). Most editors I use by default will *RENDER* a tab as X spaces, not actually *CREATE* X spaces. If it renders as X, you can easily change the rendering. But once they've become spaces, you can't go back (easily anyway).

      • Please, somebody, give me a truly valid reason why spaces are better than tabs, empirically. Thanks.

        Every editor worth using has a function that makes it automatically insert spaces when you press Tab - but very few have functions that make them automatically insert tabs when you press Space.

        Therefore, it's easier to configure your editor to insert the right sort of spacing whichever key you press if you're using spaces rather than tabs. Therefore, using spaces means you're less likely to end up with mi
    • unless (Score:4, Informative)

      by hding ( 309275 ) on Friday October 22, 2004 @03:38PM (#10603116)
      isn't unique to Perl. It exists, for example, in Common Lisp.
  • by xmas2003 ( 739875 ) on Friday October 22, 2004 @10:30AM (#10598423) Homepage
    I use Perl for my halloween webcam [komar.org] - same code is used in the christmas webcam [komar.org] ... and thought I had it in pretty decent shape ... until the Slashdot thundering herd descended on it [slashdot.org] and gave it one heck of a stress test.

    For instance, flock is your friend ... and as I outline in my slashdot effect analysis [komar.org] you had better be prepared to handle race conditions. Ignoring the web server overload (mod_perl would have helped here), the code actually hung in there fairly well as I've learned from past "mistakes" when I've seen some pretty funky error messages crop up ... but even this time around, there was two minor corner cases I failed to account for (had never been "tickled" before) ... but those are fixed now so I'll be "more" ready if my christmas lights [komar.org] show up on Slashdot again ... but then again, you are never really "ready" for Slashdot! ;-)

  • by Anonymous Coward on Friday October 22, 2004 @10:31AM (#10598428)
    Perl is an incredibly flexible language, but its ease of use can lead to some sloppy and lazy programming habits. We're all guilty of them

    Are you accusing me of writing PERL? Come over here and say that again!

  • ||= very handy optimization... especially in a persistant environment such as mod_perl or speedy cgi.
    • but what does it do?
      • It's a shorthand operator. If you want to add a number to a variable, you can do this:

        $foobar += 42;

        Which is effectively this:

        $foobar = $foobar + 42;

        ||= works the same way, but with the || operator, so

        $quux ||= 'foo';

        works like

        $quux = $quux || 'foo';

        It sets $quux to 'foo' if $quux doesn't already contain something (which evaluates to a "true" condition). If not, it does nothing at all to $quux.

  • Many optimizations listed in the article are not pertinent to Perl, but to any programming language, and as such are inapropriate to be there. Like the part about avoiding calling functions inside loops, short-circuit logic, sorting, etc..

    But there are some good tips there, too: the part about string handling, references, and the AutoLoader.
  • by Anonymous Coward
    I'm still working through it, but I cannot reproduce its purported effects.

    First it has a syntactical error with the "x" operator; it puts the number on the left and the string on the right, but the actual syntax it the other way around. If the author had actually tried to run his examples, he would have noticed this.

    Then the author says that putting as much text in a single-quoted string as possible better, and says that something like:
    print 'aaaaaaaaaaaaaaaaaa',"\n" ;
    is better than:
    print "aaa
    • Take his examples with a grain of salt. A number of the examples may be flawed in some cases, mostly because the quantities of data involved are so small that performance bottlenecks are moved to other areas. This is a good lesson for performance benchmarking: Know where your bottlenecks are. The ideas in the article are mostly valid, but they just don't apply when this is not where your bottleneck is.

      Incidentally, I am getting a slightly better speed on the singlequote example (as claimed). My times a
  • by cryptor3 ( 572787 ) on Friday October 22, 2004 @12:26PM (#10599765) Journal
    In the article, the author mentions that a faster way of implementing this sort:
    my @marksorted = sort {sprintf('%s%s%s',
    $marked_items->{$b}->{'upddate'},
    $marked_items->{$b}->{'updtime'},
    $marked_items->{$a}->{itemid}) <=>
    sprintf('%s%s%s',
    $marked_items->{$a}->{'upddate'},
    $marked_items->{$a}->{'updtime'},
    $marked_items->{$a}->{itemid}) } keys %{$marked_items};
    is this sort, which pre-computes a "sort" field for each record. (of course, at the expense of memory):
    map { $marked_items->{$_}->{sort} = sprintf('%s%s%s',
    $marked_items->{$_}->{'upddate'},
    $marked_items->{$_}->{'updtime'},
    $marked_items->{$_}->{itemid}) } keys %{$marked_items};
    my @marksorted = sort { $marked_items->{$b}->{sort} <=>
    $marked_items->{$a}->{sort} } keys %{$marked_items};
    I argue that this implementation is flawed, because the fields can run together, so for example, if you had the following data:

    Data object 1: upddate = 111, updtime = 1100, itemid = 200
    Data object 2: upddate = 1111, updtime = 100, itemid = 200

    So both strings would have a sort value of 111110200, but of course, data object 1 should be sorted before data object 2. Using delimiters in the sprintf statement will ensure that different fields are marked as different, but they will interfere with the sort order.

    Another problem is that if your sort string is too long, perl may convert it to a floating point number and thus lose the data from the later fields.

    The more correct way to do this sort is
    my @marksorted = sort {
    $marked_items->{$b}->{'upddate'} <=> $marked_items->{$a}->{'upddate'} ||
    $marked_items->{$b}->{'updtime'} <=> $marked_items->{$a}->{'updtime'} ||
    $marked_items->{$b}->{'itemid' } <=> $marked_items->{$a}->{'itemid'}
    } keys %{$marked_items};
    The added benefit of this method is that it definitely won't have overflow problems (which may be the case in the above examples, because "<=>" is the numeric compare operator. Had the author used "cmp", there would then be a quantity of numeric comparisons proportional to the length of the sort string.

    The other benefit of my sort is that it is more flexible. you can change the "<=>" operator to a "cmp" operator if one of your fields is string data.

    The sort that I propose (one I've been using) may or may not be faster than the "faster" sort proposed by the author, but then again, speed is nothing without correctness.
  • Look, this kind of "squeeze the last bit of performance" exercise can be nice fun for assembly, or possibly C, programmers, but when have you had something that was acceptable as a perl script, but only after extensive optimization?

    Better yet, I would have liked pointers on how to test code snippets for performance (such as illustrating the use of Benchmark or Devel::SmallProf), and then possibly a few pointers like this. (and why was Memoize left out of an article like this?) This sounds like someone writing perl who'd rather be writing assembly code.

    In optimizing my (and others') perl scripts, the best tools I've found are the profiler and an understanding of what the code is supposed to do. That, and changing the nature of deployment of the program - from a cgi script to mod_perl, for example. All these little techniques are chasing after grains of sand, when there's a big rock right in front of your face.
  • by cryptor3 ( 572787 ) on Friday October 22, 2004 @01:20PM (#10600780) Journal
    I have a friend who works at a big company that provides a lot of "utility" to its customers.

    They run perl scripts all the time to crunch text files containing lots of data coming in from remote sensors and stuff like that. He told me that the more senior guys have the philosophy is "Optimize? nah, just let it run the extra 20 minutes."

    And they're talking about scripts that get run in a cron job DAILY.
  • by Anonymous Coward
    ... where the optimized code is easier to read.
  • parse tree (Score:3, Interesting)

    by Doc Ruby ( 173196 ) on Friday October 22, 2004 @07:38PM (#10605576) Homepage Journal
    Perl compiles its code into an intermediary "tree" [unix.org.ua] of logic nodes (Perl "opcodes"). Are there any topology strategies for optimizing that tree, in the graph itself? Any visualization tools that let Perl generate the tree, then let a programmer change the tree, then complete the compilation of the new tree to new code? Is Parrot/Perl6 making any of these strategies more feasible, or are they all going away?
  • by mshiltonj ( 220311 ) <mshiltonj AT gmail DOT com> on Friday October 22, 2004 @07:58PM (#10605709) Homepage Journal
    DAY 1:
    Manager: How many lines of code did you write today?
    Developer: One.

    DAY 2:
    Manager: How many lines of code did you write today?
    Developer: One.

    Day 3:
    Manager: How many lines of code did you write today?
    Developer: One.
    Manager: Are you telling me that in three days you've only mangaged to write three lines of code?
    Developer: You don't understand -- I've been working on the same line of code all three days.
    Manager: (pauses) You're writing in perl again, aren't you?
  • My 0.02 Euro ;) (Score:4, Interesting)

    by kompiluj ( 677438 ) on Saturday October 23, 2004 @02:37PM (#10610087)
    Well for me the greatest optimization is Perl itself, which allows to quickly write potent code. It spares the programmer's time, which costs much more than machine time. And as to optimization - well I think that a good optimizing compiler should do the job - you know I couldn't recognize my inefficient C++ code after running it through the Intel C++ compiler - it has improved soooo much!

"Imitation is the sincerest form of television." -- The New Mighty Mouse

Working...