← Index
NYTProf Performance Profile   « block view • line view • sub view »
For ddd2.pl
  Run on Tue May 25 16:52:24 2010
Reported on Tue May 25 16:56:59 2010

File /usr/local/lib/perl5/5.8.8/AutoLoader.pm
Statements Executed 189
Statement Execution Time 5.91ms
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
3331.16ms1.40msAutoLoader::::importAutoLoader::import
522185µs185µsAutoLoader::::CORE:regcompAutoLoader::CORE:regcomp (opcode)
1252132µs132µsAutoLoader::::CORE:substAutoLoader::CORE:subst (opcode)
21275µs75µsAutoLoader::::CORE:ftereadAutoLoader::CORE:fteread (opcode)
102266µs66µsAutoLoader::::CORE:substcontAutoLoader::CORE:substcont (opcode)
21242µs42µsAutoLoader::::CORE:matchAutoLoader::CORE:match (opcode)
11116µs16µsAutoLoader::::__ANON__[:96]AutoLoader::__ANON__[:96]
0000s0sAutoLoader::::AUTOLOADAutoLoader::AUTOLOAD
0000s0sAutoLoader::::BEGINAutoLoader::BEGIN
0000s0sAutoLoader::::unimportAutoLoader::unimport
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1package AutoLoader;
2
3392µs127µsuse strict;
# spent 27µs making 1 call to strict::import
43193µsuse 5.006_001;
5
615µsour($VERSION, $AUTOLOAD);
7
815µsmy $is_dosish;
914µsmy $is_epoc;
1015µsmy $is_vms;
1114µsmy $is_macos;
12
13BEGIN {
14111µs $is_dosish = $^O eq 'dos' || $^O eq 'os2' || $^O eq 'MSWin32' || $^O eq 'NetWare';
1515µs $is_epoc = $^O eq 'epoc';
1615µs $is_vms = $^O eq 'VMS';
1715µs $is_macos = $^O eq 'MacOS';
1816µs $VERSION = '5.60';
191713µs}
20
21AUTOLOAD {
22213µs my $sub = $AUTOLOAD;
2328µs my $filename;
24 # Braces used to preserve $1 et al.
25 {
26 # Try to find the autoloaded file from the package-qualified
27 # name of the sub. e.g., if the sub needed is
28 # Getopt::Long::GetOptions(), then $INC{Getopt/Long.pm} is
29 # something like '/usr/lib/perl5/Getopt/Long.pm', and the
30 # autoload file is '/usr/lib/perl5/auto/Getopt/Long/GetOptions.al'.
31 #
32 # However, if @INC is a relative path, this might not work. If,
33 # for example, @INC = ('lib'), then $INC{Getopt/Long.pm} is
34 # 'lib/Getopt/Long.pm', and we want to require
35 # 'auto/Getopt/Long/GetOptions.al' (without the leading 'lib').
36 # In this case, we simple prepend the 'auto/' and let the
37 # C<require> take care of the searching for us.
38
394106µs242µs my ($pkg,$func) = ($sub =~ /(.*)::([^:]+)$/);
# spent 42µs making 2 calls to AutoLoader::CORE:match, avg 21µs/call
40245µs215µs $pkg =~ s#::#/#g;
# spent 15µs making 2 calls to AutoLoader::CORE:subst, avg 8µs/call
41228µs if (defined($filename = $INC{"$pkg.pm"})) {
42219µs if ($is_macos) {
43 $pkg =~ tr#/#:#;
44 $filename =~ s#^(.*)$pkg\.pm\z#$1auto:$pkg:$func.al#s;
45 } else {
462220µs8108µs $filename =~ s#^(.*)$pkg\.pm\z#$1auto/$pkg/$func.al#s;
# spent 62µs making 2 calls to AutoLoader::CORE:regcomp, avg 31µs/call # spent 28µs making 4 calls to AutoLoader::CORE:substcont, avg 7µs/call # spent 18µs making 2 calls to AutoLoader::CORE:subst, avg 9µs/call
47 }
48
49 # if the file exists, then make sure that it is a
50 # a fully anchored path (i.e either '/usr/lib/auto/foo/bar.al',
51 # or './lib/auto/foo/bar.al'. This avoids C<require> searching
52 # (and failing) to find the 'lib/auto/foo/bar.al' because it
53 # looked for 'lib/lib/auto/foo/bar.al', given @INC = ('lib').
54
552132µs275µs if (-r $filename) {
# spent 75µs making 2 calls to AutoLoader::CORE:fteread, avg 38µs/call
56 unless ($filename =~ m|^/|s) {
57 if ($is_dosish) {
58 unless ($filename =~ m{^([a-z]:)?[\\/]}is) {
59 if ($^O ne 'NetWare') {
60 $filename = "./$filename";
61 } else {
62 $filename = "$filename";
63 }
64 }
65 }
66 elsif ($is_epoc) {
67 unless ($filename =~ m{^([a-z?]:)?[\\/]}is) {
68 $filename = "./$filename";
69 }
70 }
71 elsif ($is_vms) {
72 # XXX todo by VMSmiths
73 $filename = "./$filename";
74 }
75 elsif (!$is_macos) {
76 $filename = "./$filename";
77 }
78 }
79 }
80 else {
81211µs $filename = undef;
82 }
83 }
84220µs unless (defined $filename) {
85 # let C<require> do the searching
86214µs $filename = "auto/$sub.al";
87271µs221µs $filename =~ s#::#/#g;
# spent 21µs making 2 calls to AutoLoader::CORE:subst, avg 11µs/call
88 }
89 }
90210µs my $save = $@;
912680µs local $!; # Do not munge the value.
926304µs eval { local $SIG{__DIE__}; require $filename };
93220µs if ($@) {
94225µs if (substr($sub,-9) eq '::DESTROY') {
953517µs1100µs no strict 'refs';
# spent 100µs making 1 call to strict::unimport
9675404µs
# spent 16µs within AutoLoader::__ANON__[/usr/local/lib/perl5/5.8.8/AutoLoader.pm:96] which was called # once (16µs+0s) by Wiki::DB::Wiki::BEGIN at line 116
*$sub = sub {};
97210µs $@ = undef;
98 } elsif ($@ =~ /^Can't locate/) {
99 # The load might just have failed because the filename was too
100 # long for some old SVR3 systems which treat long names as errors.
101 # If we can successfully truncate a long name then it's worth a go.
102 # There is a slight risk that we could pick up the wrong file here
103 # but autosplit should have warned about that when splitting.
104 if ($filename =~ s/(\w{12,})\.al$/substr($1,0,11).".al"/e){
105 eval { local $SIG{__DIE__}; require $filename };
106 }
107 }
10829µs if ($@){
109 $@ =~ s/ at .*\n//;
110 my $error = $@;
111 require Carp;
112 Carp::croak($error);
113 }
114 }
11529µs $@ = $save;
116236µs116µs goto &$sub;
# spent 16µs making 1 call to AutoLoader::__ANON__[AutoLoader.pm:96]
117}
118
119
# spent 1.40ms (1.16+239µs) within AutoLoader::import which was called 3 times, avg 468µs/call: # once (528µs+67µs) by base::import at line 22 of Storable.pm # once (318µs+97µs) by Net::HTTP::Methods::zlib_ok at line 6 of Compress/Zlib.pm # once (318µs+75µs) by Net::HTTP::Methods::zlib_ok at line 6 of Compress/Raw/Zlib.pm
sub import {
120319µs my $pkg = shift;
121319µs my $callpkg = caller;
122
123 #
124 # Export symbols, but not by accident of inheritance.
125 #
126
127333µs if ($pkg eq 'AutoLoader') {
1283561µs1103µs no strict 'refs';
# spent 103µs making 1 call to strict::unimport
129316µs *{ $callpkg . '::AUTOLOAD' } = \&AUTOLOAD
130 if @_ and $_[0] =~ /^&?AUTOLOAD$/;
131 }
132
133 #
134 # Try to find the autosplit index file. Eg., if the call package
135 # is POSIX, then $INC{POSIX.pm} is something like
136 # '/usr/local/lib/perl5/POSIX.pm', and the autosplit index file is in
137 # '/usr/local/lib/perl5/auto/POSIX/autosplit.ix', so we require that.
138 #
139 # However, if @INC is a relative path, this might not work. If,
140 # for example, @INC = ('lib'), then
141 # $INC{POSIX.pm} is 'lib/POSIX.pm', and we want to require
142 # 'auto/POSIX/autosplit.ix' (without the leading 'lib').
143 #
144
1453121µs337µs (my $calldir = $callpkg) =~ s#::#/#g;
# spent 37µs making 3 calls to AutoLoader::CORE:subst, avg 12µs/call
146326µs my $path = $INC{$calldir . '.pm'};
147393µs if (defined($path)) {
148 # Try absolute path name.
149328µs if ($is_macos) {
150 (my $malldir = $calldir) =~ tr#/#:#;
151 $path =~ s#^(.*)$malldir\.pm\z#$1auto:$malldir:autosplit.ix#s;
152 } else {
1533365µs12202µs $path =~ s#^(.*)$calldir\.pm\z#$1auto/$calldir/autosplit.ix#;
# spent 123µs making 3 calls to AutoLoader::CORE:regcomp, avg 41µs/call # spent 41µs making 3 calls to AutoLoader::CORE:subst, avg 14µs/call # spent 38µs making 6 calls to AutoLoader::CORE:substcont, avg 6µs/call
154 }
155
1566634µs eval { require $path; };
157 # If that failed, try relative path with normal @INC searching.
158312µs if ($@) {
159 $path ="auto/$calldir/autosplit.ix";
160 eval { require $path; };
161 }
162315µs if ($@) {
163 my $error = $@;
164 require Carp;
165 Carp::carp($error);
166 }
167 }
168}
169
170sub unimport {
171 my $callpkg = caller;
172
1733194µs195µs no strict 'refs';
# spent 95µs making 1 call to strict::unimport
174 my $symname = $callpkg . '::AUTOLOAD';
175 undef *{ $symname } if \&{ $symname } == \&AUTOLOAD;
176 *{ $symname } = \&{ $symname };
177}
178
179115µs1;
180
181__END__
182
183=head1 NAME
184
185AutoLoader - load subroutines only on demand
186
187=head1 SYNOPSIS
188
189 package Foo;
190 use AutoLoader 'AUTOLOAD'; # import the default AUTOLOAD subroutine
191
192 package Bar;
193 use AutoLoader; # don't import AUTOLOAD, define our own
194 sub AUTOLOAD {
195 ...
196 $AutoLoader::AUTOLOAD = "...";
197 goto &AutoLoader::AUTOLOAD;
198 }
199
200=head1 DESCRIPTION
201
202The B<AutoLoader> module works with the B<AutoSplit> module and the
203C<__END__> token to defer the loading of some subroutines until they are
204used rather than loading them all at once.
205
206To use B<AutoLoader>, the author of a module has to place the
207definitions of subroutines to be autoloaded after an C<__END__> token.
208(See L<perldata>.) The B<AutoSplit> module can then be run manually to
209extract the definitions into individual files F<auto/funcname.al>.
210
211B<AutoLoader> implements an AUTOLOAD subroutine. When an undefined
212subroutine in is called in a client module of B<AutoLoader>,
213B<AutoLoader>'s AUTOLOAD subroutine attempts to locate the subroutine in a
214file with a name related to the location of the file from which the
215client module was read. As an example, if F<POSIX.pm> is located in
216F</usr/local/lib/perl5/POSIX.pm>, B<AutoLoader> will look for perl
217subroutines B<POSIX> in F</usr/local/lib/perl5/auto/POSIX/*.al>, where
218the C<.al> file has the same name as the subroutine, sans package. If
219such a file exists, AUTOLOAD will read and evaluate it,
220thus (presumably) defining the needed subroutine. AUTOLOAD will then
221C<goto> the newly defined subroutine.
222
223Once this process completes for a given function, it is defined, so
224future calls to the subroutine will bypass the AUTOLOAD mechanism.
225
226=head2 Subroutine Stubs
227
228In order for object method lookup and/or prototype checking to operate
229correctly even when methods have not yet been defined it is necessary to
230"forward declare" each subroutine (as in C<sub NAME;>). See
231L<perlsub/"SYNOPSIS">. Such forward declaration creates "subroutine
232stubs", which are place holders with no code.
233
234The AutoSplit and B<AutoLoader> modules automate the creation of forward
235declarations. The AutoSplit module creates an 'index' file containing
236forward declarations of all the AutoSplit subroutines. When the
237AutoLoader module is 'use'd it loads these declarations into its callers
238package.
239
240Because of this mechanism it is important that B<AutoLoader> is always
241C<use>d and not C<require>d.
242
243=head2 Using B<AutoLoader>'s AUTOLOAD Subroutine
244
245In order to use B<AutoLoader>'s AUTOLOAD subroutine you I<must>
246explicitly import it:
247
248 use AutoLoader 'AUTOLOAD';
249
250=head2 Overriding B<AutoLoader>'s AUTOLOAD Subroutine
251
252Some modules, mainly extensions, provide their own AUTOLOAD subroutines.
253They typically need to check for some special cases (such as constants)
254and then fallback to B<AutoLoader>'s AUTOLOAD for the rest.
255
256Such modules should I<not> import B<AutoLoader>'s AUTOLOAD subroutine.
257Instead, they should define their own AUTOLOAD subroutines along these
258lines:
259
260 use AutoLoader;
261 use Carp;
262
263 sub AUTOLOAD {
264 my $sub = $AUTOLOAD;
265 (my $constname = $sub) =~ s/.*:://;
266 my $val = constant($constname, @_ ? $_[0] : 0);
267 if ($! != 0) {
268 if ($! =~ /Invalid/ || $!{EINVAL}) {
269 $AutoLoader::AUTOLOAD = $sub;
270 goto &AutoLoader::AUTOLOAD;
271 }
272 else {
273 croak "Your vendor has not defined constant $constname";
274 }
275 }
276 *$sub = sub { $val }; # same as: eval "sub $sub { $val }";
277 goto &$sub;
278 }
279
280If any module's own AUTOLOAD subroutine has no need to fallback to the
281AutoLoader's AUTOLOAD subroutine (because it doesn't have any AutoSplit
282subroutines), then that module should not use B<AutoLoader> at all.
283
284=head2 Package Lexicals
285
286Package lexicals declared with C<my> in the main block of a package
287using B<AutoLoader> will not be visible to auto-loaded subroutines, due to
288the fact that the given scope ends at the C<__END__> marker. A module
289using such variables as package globals will not work properly under the
290B<AutoLoader>.
291
292The C<vars> pragma (see L<perlmod/"vars">) may be used in such
293situations as an alternative to explicitly qualifying all globals with
294the package namespace. Variables pre-declared with this pragma will be
295visible to any autoloaded routines (but will not be invisible outside
296the package, unfortunately).
297
298=head2 Not Using AutoLoader
299
300You can stop using AutoLoader by simply
301
302 no AutoLoader;
303
304=head2 B<AutoLoader> vs. B<SelfLoader>
305
306The B<AutoLoader> is similar in purpose to B<SelfLoader>: both delay the
307loading of subroutines.
308
309B<SelfLoader> uses the C<__DATA__> marker rather than C<__END__>.
310While this avoids the use of a hierarchy of disk files and the
311associated open/close for each routine loaded, B<SelfLoader> suffers a
312startup speed disadvantage in the one-time parsing of the lines after
313C<__DATA__>, after which routines are cached. B<SelfLoader> can also
314handle multiple packages in a file.
315
316B<AutoLoader> only reads code as it is requested, and in many cases
317should be faster, but requires a mechanism like B<AutoSplit> be used to
318create the individual files. L<ExtUtils::MakeMaker> will invoke
319B<AutoSplit> automatically if B<AutoLoader> is used in a module source
320file.
321
322=head1 CAVEATS
323
324AutoLoaders prior to Perl 5.002 had a slightly different interface. Any
325old modules which use B<AutoLoader> should be changed to the new calling
326style. Typically this just means changing a require to a use, adding
327the explicit C<'AUTOLOAD'> import if needed, and removing B<AutoLoader>
328from C<@ISA>.
329
330On systems with restrictions on file name length, the file corresponding
331to a subroutine may have a shorter name that the routine itself. This
332can lead to conflicting file names. The I<AutoSplit> package warns of
333these potential conflicts when used to split a module.
334
335AutoLoader may fail to find the autosplit files (or even find the wrong
336ones) in cases where C<@INC> contains relative paths, B<and> the program
337does C<chdir>.
338
339=head1 SEE ALSO
340
341L<SelfLoader> - an autoloader that doesn't use external files.
342
343=cut
# spent 75µs within AutoLoader::CORE:fteread which was called 2 times, avg 38µs/call: # 2 times (75µs+0s) by AutoLoader::AUTOLOAD or base::import at line 55 of AutoLoader.pm, avg 38µs/call
sub AutoLoader::CORE:fteread; # xsub
# spent 42µs within AutoLoader::CORE:match which was called 2 times, avg 21µs/call: # 2 times (42µs+0s) by AutoLoader::AUTOLOAD or base::import at line 39 of AutoLoader.pm, avg 21µs/call
sub AutoLoader::CORE:match; # xsub
# spent 185µs within AutoLoader::CORE:regcomp which was called 5 times, avg 37µs/call: # 3 times (123µs+0s) by AutoLoader::import at line 153 of AutoLoader.pm, avg 41µs/call # 2 times (62µs+0s) by AutoLoader::AUTOLOAD or base::import at line 46 of AutoLoader.pm, avg 31µs/call
sub AutoLoader::CORE:regcomp; # xsub
# spent 132µs within AutoLoader::CORE:subst which was called 12 times, avg 11µs/call: # 3 times (41µs+0s) by AutoLoader::import at line 153 of AutoLoader.pm, avg 14µs/call # 3 times (37µs+0s) by AutoLoader::import at line 145 of AutoLoader.pm, avg 12µs/call # 2 times (21µs+0s) by AutoLoader::AUTOLOAD or base::import at line 87 of AutoLoader.pm, avg 11µs/call # 2 times (18µs+0s) by AutoLoader::AUTOLOAD or base::import at line 46 of AutoLoader.pm, avg 9µs/call # 2 times (15µs+0s) by AutoLoader::AUTOLOAD or base::import at line 40 of AutoLoader.pm, avg 8µs/call
sub AutoLoader::CORE:subst; # xsub
# spent 66µs within AutoLoader::CORE:substcont which was called 10 times, avg 7µs/call: # 6 times (38µs+0s) by AutoLoader::import at line 153 of AutoLoader.pm, avg 6µs/call # 4 times (28µs+0s) by AutoLoader::AUTOLOAD or base::import at line 46 of AutoLoader.pm, avg 7µs/call
sub AutoLoader::CORE:substcont; # xsub
Report produced by the NYTProf 3.11 Perl profiler, developed by Tim Bunce and Adam Kaplan.