When you are looking at the bigger picture you might want to take in account (and if that is interesting measure it too) that some of the modules rely heavily on AUTOLOAD and create some of their own functions or load additional modules in run time and based on the flow of your program.

Specifically CGI.pm is mostly a huge string called $AUTOLOADED_ROUTINES from where the rest of the code extracts the functions as they are needed.

POSIX is another example of a big module that uses AUTOLOAD. I wanted to test that one specifically because sometimes I hear that people are afraid of using it because it is "too big". However, for the "null use" of POSIX, it's one of the fastest to start up. I often use it just because I need a little function such as floor or ceil.

speed is one thing.

what might be also interesting is the memory footprint without POSIX, in "null use" and when using 1-2-3 functions.

How would you feel about posting your benchmarking code so we can try this on other platforms?

There was not really code as such, just a quick and dirty series of shell commands. It went something like this:

#!/bin/bash
 
modules="Archive::Tar Archive::Zip CGI Class::DBI DBI Data::Dumper Lin
+gua::EN::Inflect Math::Trig POSIX Template XML::SAX XML::Simple YAML 
+diagnostics strict warnings"

export TIMEFORMAT="%R"
rm -f table
for m in $modules; do
    time perl -M$m -e1;
    for i in `seq 1 10`; do
        time perl -M$m -e1;
    done &> $m
    echo -ne "$m\t" >> table
    awk '{t+=$1} END{print t/10}' $m >> table
done
 
sort -k2 -rn table > table.sorted
[download]

The part that computes "all" and "none" is left as an exercise to the reader. ;-)

I hope I won't be downvoted for using shell instead of Perl! ;-) Sadly, this makes the test less portable.

Hm, it wouldn't be very hard to do this with Perl. I can think of two approaches: either invoke perl via system(), or use string-based eval.

The following can be used like:
# this_script.pl [--eval] [--perl /my/perl/interpreter] module module2 module3

use strict;
use warnings;
use Time::HiRes;
use Benchmark ':hireswallclock',':all';
use Getopt::Long;

my $PERL = 'C:\\Perl\bin\perl.exe';
my $use_eval = 0;

GetOptions ( 'perl=s' => \$PERL, 'eval' => \$use_eval );

my %testhash = map { 
   $_ => ( $use_eval ? "eval 'use $_'" : "system('$PERL', '-M$_ ', '-e
+1')" )
} @ARGV;

timethese( ($use_eval ? 10000 : 1000), \%testhash );
[download]

This one was created to work with ActiveState Perl on Windows. Pass the --perl parameter to use it on other platforms.

Update:itub confirms my suspicions that eval isn't as accurate a test as the system route. Thanks for the explanation of why, itub! It's worth noting that the system call is the default approach in the code above.

Updates:

• 2005-07.Jul-26 : clarified preferred use of system over eval, thanks to itub
<-radiant.matrix->
Larry Wall is Yoda: there is no try{} (ok, except in Perl6; way to ruin a joke, Larry! ;P)
The Code that can be seen is not the true Code
"In any sufficiently large group of people, most are idiots" - Kaa's Law

Using strict and warnings doesn't cost that much in terms of startup time.

I know, that's why I qualified the statement with "in terms of startup time". ;-)

Added: ikegami and the Anonymous Monk are right, of course; I misunderstood the parent node.

That's still ambiguous. You meansured the effect on the module's startup time, but not on perl's startup time for strict and warnings since the effect varies depending on the script begin loaded.