Now, have you actually identified the sections of your code that are causing any slowdowns? Over 90% of all time taken in the average application is spent in less than 10% of the code. You might want to look at various profiles, like Devel::DProf and Devel::SmallProf.

Another important item is you say I need my code to go as fast as possible. What does this mean? The human brain can only notice things that take longer than a hundredth of a second (or so). What does it gain you if you speed your code up by 50%, but only shave a thousandth of a second off the runtime?

When I code web applications, I try and keep each page under 5 seconds from request to render. That's the time that most people feel a webpage should render in. Client/server applications generally need to respond in under 1-2 seconds. Cellphone applications that go to the network can take up to 30 seconds and still be reasonable. In other words - how fast does fast really need to be?

If you aren't using Unicode, specify -C0 on the shebang line. Character conversions are very expensive.

Many times upon profiling the code as recommended by dragonchild, you'll find that just a few segments of code are your bottlenecks. In some instances, the only solution is to code them in C, but more often than not, rethinking the design can save you a lot of execution time without dropping into C.

For example, hash lookups are faster by a long shot than grepping a list, if the dataset is large. Maybe nested foreach loops can be replaced by a smarter algorithm that doesn't require so much nested looping. Perhaps database inserts can be done in larger transactions, only committing after 1000 rows, instead of committing individual rows. The list goes on and on. Before looking for a lower level language, first look to see if you're getting the most out of your higher level language. An inefficient algorithm written in Perl will still be inefficient in C.

If you need a general speedup, here are some boosters:

• Use a better algorithm.
• Ditch Perl, write it in C.
• Shutdown anything else that's running on the machine.
• Invest in hardware: more memory, faster disks, more I/O controllers (and more spindles), different RAID scheme, faster CPU, faster network, more network cards.

There are many things that can slow your script down. As others have said usually 5% of the code consumes 90% of the execution time. The trick is to identify where those key routines are and look at ways to speed them up.

I have used tricks like caching results that can have a significant effect:

sub routine1
  {
    my($arg1,$arg2) = @_;
      ...
    return $result;
  }
[download]

Is changed to:

{
  my %cached_results;

sub routine1
  {
    my($arg1,$arg2) = @_;
    return $cached_results{"$arg1||$arg2"}
            if(defined $cached_results{"$arg1||$arg2"});
      ...
    $cached_results{"$arg1||$arg2"} = $result;
    return $result;
  }

sub clear_cache1
  {
    %cached_results = ();
  }
}
[download]

I recently had a case where I was using .= to build up a string, converting the routine to pushing strings on to and array and only concatenating at the end of the function reduced memory usage by a factor of 100 and increased speed by a factor of 10 for that one routine.

It is not worth hand coding modules in C until you have tried these types of tricks. The extra maintenance cost will swamp the benefit of speed you get.