← Index
NYTProf Performance Profile   « line view »
For script/ponapi
  Run on Wed Feb 10 15:51:26 2016
Reported on Thu Feb 11 09:43:09 2016

Filename/usr/share/perl/5.18/Carp.pm
StatementsExecuted 456 statements in 2.56ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
61189µs123µsCarp::::format_argCarp::format_arg
31186µs220µsCarp::::caller_infoCarp::caller_info
31153µs133µsCarp::::short_error_locCarp::short_error_loc
31129µs249µsCarp::::ret_summaryCarp::ret_summary
61127µs43µsCarp::::get_statusCarp::get_status
183126µs26µsCarp::::_cgcCarp::_cgc
31124µs465µsCarp::::croakCarp::croak
62123µs66µsCarp::::trustsCarp::trusts
31122µs428µsCarp::::shortmessCarp::shortmess
61116µs16µsCarp::::trusts_directlyCarp::trusts_directly
31116µs398µsCarp::::shortmess_heavyCarp::shortmess_heavy
11115µs15µsCarp::::BEGIN@3Carp::BEGIN@3
122110µs10µsCarp::::CORE:substCarp::CORE:subst (opcode)
6119µs9µsCarp::::str_len_trimCarp::str_len_trim
6118µs8µsCarp::::CORE:matchCarp::CORE:match (opcode)
1117µs22µsCarp::::BEGIN@434Carp::BEGIN@434
3117µs7µsCarp::::get_subnameCarp::get_subname
1117µs12µsCarp::::BEGIN@5Carp::BEGIN@5
1116µs15µsCarp::::BEGIN@433Carp::BEGIN@433
1116µs14µsCarp::::BEGIN@441Carp::BEGIN@441
1116µs6µsCarp::::BEGIN@105Carp::BEGIN@105
1115µs12µsCarp::::BEGIN@67Carp::BEGIN@67
1115µs5µsCarp::::BEGIN@17Carp::BEGIN@17
1115µs5µsCarp::::BEGIN@7Carp::BEGIN@7
1115µs14µsCarp::::BEGIN@4Carp::BEGIN@4
1115µs12µsCarp::::BEGIN@448Carp::BEGIN@448
1115µs11µsCarp::::BEGIN@18Carp::BEGIN@18
1114µs10µsCarp::::BEGIN@8Carp::BEGIN@8
0000s0sCarp::::__ANON__[:13]Carp::__ANON__[:13]
0000s0sCarp::::__ANON__[:23]Carp::__ANON__[:23]
0000s0sCarp::::carpCarp::carp
0000s0sCarp::::cluckCarp::cluck
0000s0sCarp::::confessCarp::confess
0000s0sCarp::::export_failCarp::export_fail
0000s0sCarp::::long_error_locCarp::long_error_loc
0000s0sCarp::::longmessCarp::longmess
0000s0sCarp::::longmess_heavyCarp::longmess_heavy
0000s0sCarp::::ret_backtraceCarp::ret_backtrace
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1package Carp;
2
3340µs115µs
# spent 15µs within Carp::BEGIN@3 which was called: # once (15µs+0s) by Module::Pluggable::Object::BEGIN@7 at line 3
{ use 5.006; }
# spent 15µs making 1 call to Carp::BEGIN@3
4221µs223µs
# spent 14µs (5+9) within Carp::BEGIN@4 which was called: # once (5µs+9µs) by Module::Pluggable::Object::BEGIN@7 at line 4
use strict;
# spent 14µs making 1 call to Carp::BEGIN@4 # spent 9µs making 1 call to strict::import
5222µs217µs
# spent 12µs (7+5) within Carp::BEGIN@5 which was called: # once (7µs+5µs) by Module::Pluggable::Object::BEGIN@7 at line 5
use warnings;
# spent 12µs making 1 call to Carp::BEGIN@5 # spent 5µs making 1 call to warnings::import
6
7
# spent 5µs within Carp::BEGIN@7 which was called: # once (5µs+0s) by Module::Pluggable::Object::BEGIN@7 at line 15
BEGIN {
8268µs217µs
# spent 10µs (4+6) within Carp::BEGIN@8 which was called: # once (4µs+6µs) by Module::Pluggable::Object::BEGIN@7 at line 8
no strict "refs";
# spent 10µs making 1 call to Carp::BEGIN@8 # spent 6µs making 1 call to strict::unimport
916µs if(exists($::{"utf8::"}) && exists(*{$::{"utf8::"}}{HASH}->{"is_utf8"}) &&
10 defined(*{*{$::{"utf8::"}}{HASH}->{"is_utf8"}}{CODE})) {
11 *is_utf8 = \&{"utf8::is_utf8"};
12 } else {
13 *is_utf8 = sub { 0 };
14 }
15121µs15µs}
# spent 5µs making 1 call to Carp::BEGIN@7
16
17
# spent 5µs within Carp::BEGIN@17 which was called: # once (5µs+0s) by Module::Pluggable::Object::BEGIN@7 at line 25
BEGIN {
18258µs218µs
# spent 11µs (5+7) within Carp::BEGIN@18 which was called: # once (5µs+7µs) by Module::Pluggable::Object::BEGIN@7 at line 18
no strict "refs";
# spent 11µs making 1 call to Carp::BEGIN@18 # spent 7µs making 1 call to strict::unimport
1919µs if(exists($::{"utf8::"}) && exists(*{$::{"utf8::"}}{HASH}->{"downgrade"}) &&
20 defined(*{*{$::{"utf8::"}}{HASH}->{"downgrade"}}{CODE})) {
21 *downgrade = \&{"utf8::downgrade"};
22 } else {
23 *downgrade = sub {};
24 }
251143µs15µs}
# spent 5µs making 1 call to Carp::BEGIN@17
26
271500nsour $VERSION = '1.29';
28
291100nsour $MaxEvalLen = 0;
301100nsour $Verbose = 0;
311100nsour $CarpLevel = 0;
321100nsour $MaxArgLen = 64; # How much of each argument to print. 0 = all.
331100nsour $MaxArgNums = 8; # How many arguments to print. 0 = all.
34
3511µsrequire Exporter;
3616µsour @ISA = ('Exporter');
371700nsour @EXPORT = qw(confess croak carp);
381500nsour @EXPORT_OK = qw(cluck verbose longmess shortmess);
391200nsour @EXPORT_FAIL = qw(verbose); # hook to enable verbose mode
40
41# The members of %Internal are packages that are internal to perl.
42# Carp will not report errors from within these packages if it
43# can. The members of %CarpInternal are internal to Perl's warning
44# system. Carp will not report errors from within these packages
45# either, and will not report calls *to* these packages for carp and
46# croak. They replace $CarpLevel, which is deprecated. The
47# $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval
48# text and function arguments should be formatted when printed.
49
501100nsour %CarpInternal;
511100nsour %Internal;
52
53# disable these by default, so they can live w/o require Carp
541500ns$CarpInternal{Carp}++;
551100ns$CarpInternal{warnings}++;
561100ns$Internal{Exporter}++;
571200ns$Internal{'Exporter::Heavy'}++;
58
59# if the caller specifies verbose usage ("perl -MCarp=verbose script.pl")
60# then the following method will be called by the Exporter which knows
61# to do this thanks to @EXPORT_FAIL, above. $_[1] will contain the word
62# 'verbose'.
63
64sub export_fail { shift; $Verbose = shift if $_[0] eq 'verbose'; @_ }
65
66
# spent 26µs within Carp::_cgc which was called 18 times, avg 1µs/call: # 12 times (14µs+0s) by Carp::short_error_loc at line 354, avg 1µs/call # 3 times (8µs+0s) by Carp::shortmess at line 93, avg 3µs/call # 3 times (4µs+0s) by Carp::caller_info at line 117, avg 1µs/call
sub _cgc {
672258µs220µs
# spent 12µs (5+7) within Carp::BEGIN@67 which was called: # once (5µs+7µs) by Module::Pluggable::Object::BEGIN@7 at line 67
no strict 'refs';
# spent 12µs making 1 call to Carp::BEGIN@67 # spent 7µs making 1 call to strict::unimport
681818µs return \&{"CORE::GLOBAL::caller"} if defined &{"CORE::GLOBAL::caller"};
691826µs return;
70}
71
72sub longmess {
73 # Icky backwards compatibility wrapper. :-(
74 #
75 # The story is that the original implementation hard-coded the
76 # number of call levels to go back, so calls to longmess were off
77 # by one. Other code began calling longmess and expecting this
78 # behaviour, so the replacement has to emulate that behaviour.
79 my $cgc = _cgc();
80 my $call_pack = $cgc ? $cgc->() : caller();
81 if ( $Internal{$call_pack} or $CarpInternal{$call_pack} ) {
82 return longmess_heavy(@_);
83 }
84 else {
85 local $CarpLevel = $CarpLevel + 1;
86 return longmess_heavy(@_);
87 }
88}
89
901100nsour @CARP_NOT;
91
92
# spent 428µs (22+406) within Carp::shortmess which was called 3 times, avg 143µs/call: # 3 times (22µs+406µs) by Carp::croak at line 100, avg 143µs/call
sub shortmess {
9334µs38µs my $cgc = _cgc();
# spent 8µs making 3 calls to Carp::_cgc, avg 3µs/call
94
95 # Icky backwards compatibility wrapper. :-(
9635µs local @CARP_NOT = $cgc ? $cgc->() : caller();
9738µs3398µs shortmess_heavy(@_);
# spent 398µs making 3 calls to Carp::shortmess_heavy, avg 133µs/call
98}
99
100348µs6441µs
# spent 465µs (24+441) within Carp::croak which was called 3 times, avg 155µs/call: # 3 times (24µs+441µs) by Exporter::Heavy::heavy_export at line 140 of Exporter/Heavy.pm, avg 155µs/call
sub croak { die shortmess @_ }
# spent 428µs making 3 calls to Carp::shortmess, avg 143µs/call # spent 13µs making 3 calls to Exporter::Heavy::__ANON__[Exporter/Heavy.pm:44], avg 4µs/call
101sub confess { die longmess @_ }
102sub carp { warn shortmess @_ }
103sub cluck { warn longmess @_ }
104
105
# spent 6µs within Carp::BEGIN@105 which was called: # once (6µs+0s) by Module::Pluggable::Object::BEGIN@7 at line 112
BEGIN {
10616µs if("$]" >= 5.015002 || ("$]" >= 5.014002 && "$]" < 5.015) ||
107 ("$]" >= 5.012005 && "$]" < 5.013)) {
108 *CALLER_OVERRIDE_CHECK_OK = sub () { 1 };
109 } else {
110 *CALLER_OVERRIDE_CHECK_OK = sub () { 0 };
111 }
11211.26ms16µs}
# spent 6µs making 1 call to Carp::BEGIN@105
113
114
# spent 220µs (86+134) within Carp::caller_info which was called 3 times, avg 73µs/call: # 3 times (86µs+134µs) by Carp::ret_summary at line 342, avg 73µs/call
sub caller_info {
11532µs my $i = shift(@_) + 1;
1163500ns my %call_info;
11732µs34µs my $cgc = _cgc();
# spent 4µs making 3 calls to Carp::_cgc, avg 1µs/call
118 {
119 # Some things override caller() but forget to implement the
120 # @DB::args part of it, which we need. We check for this by
121 # pre-populating @DB::args with a sentinel which no-one else
122 # has the address of, so that we can detect whether @DB::args
123 # has been properly populated. However, on earlier versions
124 # of perl this check tickles a bug in CORE::caller() which
125 # leaks memory. So we only check on fixed perls.
12664µs @DB::args = \$i if CALLER_OVERRIDE_CHECK_OK;
127 package DB;
128
129315µs
- -
13331µs unless ( defined $call_info{file} ) {
134 return ();
135 }
136
13734µs37µs my $sub_name = Carp::get_subname( \%call_info );
# spent 7µs making 3 calls to Carp::get_subname, avg 2µs/call
13831µs if ( $call_info{has_args} ) {
1393300ns my @args;
14031µs if (CALLER_OVERRIDE_CHECK_OK && @DB::args == 1
141 && ref $DB::args[0] eq ref \$i
142 && $DB::args[0] == \$i ) {
143 @DB::args = (); # Don't let anyone see the address of $i
144 local $@;
145 my $where = eval {
146 my $func = $cgc or return '';
147 my $gv =
148 *{
149 ( $::{"B::"} || return '') # B stash
150 ->{svref_2object} || return '' # entry in stash
151 }{CODE} # coderef in entry
152 ->($func)->GV;
153 my $package = $gv->STASH->NAME;
154 my $subname = $gv->NAME;
155 return unless defined $package && defined $subname;
156
157 # returning CORE::GLOBAL::caller isn't useful for tracing the cause:
158 return if $package eq 'CORE::GLOBAL' && $subname eq 'caller';
159 " in &${package}::$subname";
160 } || '';
161 @args
162 = "** Incomplete caller override detected$where; \@DB::args were not set **";
163 }
164 else {
16532µs @args = @DB::args;
1663300ns my $overflow;
16731µs if ( $MaxArgNums and @args > $MaxArgNums )
168 { # More than we want to show?
169 $#args = $MaxArgNums;
170 $overflow = 1;
171 }
172
173911µs6123µs @args = map { Carp::format_arg($_) } @args;
# spent 123µs making 6 calls to Carp::format_arg, avg 20µs/call
174
1753800ns if ($overflow) {
176 push @args, '...';
177 }
178 }
179
180 # Push the args onto the subroutine
181317µs $sub_name .= '(' . join( ', ', @args ) . ')';
182 }
18332µs $call_info{sub_name} = $sub_name;
184314µs return wantarray() ? %call_info : \%call_info;
185}
186
187# Transform an argument to a function into a string.
188
# spent 123µs (89+34) within Carp::format_arg which was called 6 times, avg 20µs/call: # 6 times (89µs+34µs) by Carp::caller_info at line 173, avg 20µs/call
sub format_arg {
18963µs my $arg = shift;
19061µs if ( ref($arg) ) {
191 $arg = defined($overload::VERSION) ? overload::StrVal($arg) : "$arg";
192 }
19362µs if ( defined($arg) ) {
194613µs62µs $arg =~ s/'/\\'/g;
# spent 2µs making 6 calls to Carp::CORE:subst, avg 333ns/call
19565µs69µs $arg = str_len_trim( $arg, $MaxArgLen );
# spent 9µs making 6 calls to Carp::str_len_trim, avg 1µs/call
196
197 # Quote it?
198 # Downgrade, and use [0-9] rather than \d, to avoid loading
199 # Unicode tables, which would be liable to fail if we're
200 # processing a syntax error.
201612µs63µs downgrade($arg, 1);
# spent 3µs making 6 calls to utf8::downgrade, avg 550ns/call
202639µs68µs $arg = "'$arg'" unless $arg =~ /^-?[0-9.]+\z/;
# spent 8µs making 6 calls to Carp::CORE:match, avg 1µs/call
203 }
204 else {
205 $arg = 'undef';
206 }
207
208 # The following handling of "control chars" is direct from
209 # the original code - it is broken on Unicode though.
210 # Suggestions?
211 is_utf8($arg)
212628µs1212µs or $arg =~ s/([[:cntrl:]]|[[:^ascii:]])/sprintf("\\x{%x}",ord($1))/eg;
# spent 8µs making 6 calls to Carp::CORE:subst, avg 1µs/call # spent 3µs making 6 calls to utf8::is_utf8, avg 550ns/call
21369µs return $arg;
214}
215
216# Takes an inheritance cache and a package and returns
217# an anon hash of known inheritances and anon array of
218# inheritances which consequences have not been figured
219# for.
220
# spent 43µs (27+16) within Carp::get_status which was called 6 times, avg 7µs/call: # 6 times (27µs+16µs) by Carp::trusts at line 415, avg 7µs/call
sub get_status {
2216700ns my $cache = shift;
2226700ns my $pkg = shift;
223614µs616µs $cache->{$pkg} ||= [ { $pkg => $pkg }, [ trusts_directly($pkg) ] ];
# spent 16µs making 6 calls to Carp::trusts_directly, avg 3µs/call
224612µs return @{ $cache->{$pkg} };
225}
226
227# Takes the info from caller() and figures out the name of
228# the sub/require/eval
229
# spent 7µs within Carp::get_subname which was called 3 times, avg 2µs/call: # 3 times (7µs+0s) by Carp::caller_info at line 137, avg 2µs/call
sub get_subname {
2303800ns my $info = shift;
23132µs if ( defined( $info->{evaltext} ) ) {
232 my $eval = $info->{evaltext};
233 if ( $info->{is_require} ) {
234 return "require $eval";
235 }
236 else {
237 $eval =~ s/([\\\'])/\\$1/g;
238 return "eval '" . str_len_trim( $eval, $MaxEvalLen ) . "'";
239 }
240 }
241
242 # this can happen on older perls when the sub (or the stash containing it)
243 # has been deleted
2443700ns if ( !defined( $info->{sub} ) ) {
245 return '__ANON__::__ANON__';
246 }
247
24837µs return ( $info->{sub} eq '(eval)' ) ? 'eval {...}' : $info->{sub};
249}
250
251# Figures out what call (from the point of view of the caller)
252# the long error backtrace should start at.
253sub long_error_loc {
254 my $i;
255 my $lvl = $CarpLevel;
256 {
257 ++$i;
258 my $cgc = _cgc();
259 my @caller = $cgc ? $cgc->($i) : caller($i);
260 my $pkg = $caller[0];
261 unless ( defined($pkg) ) {
262
263 # This *shouldn't* happen.
264 if (%Internal) {
265 local %Internal;
266 $i = long_error_loc();
267 last;
268 }
269 elsif (defined $caller[2]) {
270 # this can happen when the stash has been deleted
271 # in that case, just assume that it's a reasonable place to
272 # stop (the file and line data will still be intact in any
273 # case) - the only issue is that we can't detect if the
274 # deleted package was internal (so don't do that then)
275 # -doy
276 redo unless 0 > --$lvl;
277 last;
278 }
279 else {
280 return 2;
281 }
282 }
283 redo if $CarpInternal{$pkg};
284 redo unless 0 > --$lvl;
285 redo if $Internal{$pkg};
286 }
287 return $i - 1;
288}
289
290sub longmess_heavy {
291 return @_ if ref( $_[0] ); # don't break references as exceptions
292 my $i = long_error_loc();
293 return ret_backtrace( $i, @_ );
294}
295
296# Returns a full stack backtrace starting from where it is
297# told.
298sub ret_backtrace {
299 my ( $i, @error ) = @_;
300 my $mess;
301 my $err = join '', @error;
302 $i++;
303
304 my $tid_msg = '';
305 if ( defined &threads::tid ) {
306 my $tid = threads->tid;
307 $tid_msg = " thread $tid" if $tid;
308 }
309
310 my %i = caller_info($i);
311 $mess = "$err at $i{file} line $i{line}$tid_msg";
312 if( defined $. ) {
313 local $@ = '';
314 local $SIG{__DIE__};
315 eval {
316 CORE::die;
317 };
318 if($@ =~ /^Died at .*(, <.*?> line \d+).$/ ) {
319 $mess .= $1;
320 }
321 }
322 $mess .= "\.\n";
323
324 while ( my %i = caller_info( ++$i ) ) {
325 $mess .= "\t$i{sub_name} called at $i{file} line $i{line}$tid_msg\n";
326 }
327
328 return $mess;
329}
330
331
# spent 249µs (29+220) within Carp::ret_summary which was called 3 times, avg 83µs/call: # 3 times (29µs+220µs) by Carp::shortmess_heavy at line 387, avg 83µs/call
sub ret_summary {
33233µs my ( $i, @error ) = @_;
33332µs my $err = join '', @error;
3343400ns $i++;
335
3363500ns my $tid_msg = '';
3373900ns if ( defined &threads::tid ) {
338 my $tid = threads->tid;
339 $tid_msg = " thread $tid" if $tid;
340 }
341
34239µs3220µs my %i = caller_info($i);
# spent 220µs making 3 calls to Carp::caller_info, avg 73µs/call
343313µs return "$err at $i{file} line $i{line}$tid_msg\.\n";
344}
345
346
# spent 133µs (53+80) within Carp::short_error_loc which was called 3 times, avg 44µs/call: # 3 times (53µs+80µs) by Carp::shortmess_heavy at line 386, avg 44µs/call
sub short_error_loc {
347 # You have to create your (hash)ref out here, rather than defaulting it
348 # inside trusts *on a lexical*, as you want it to persist across calls.
349 # (You can default it on $_[2], but that gets messy)
35031µs my $cache = {};
3513300ns my $i = 1;
3523500ns my $lvl = $CarpLevel;
353 {
354157µs1214µs my $cgc = _cgc();
# spent 14µs making 12 calls to Carp::_cgc, avg 1µs/call
355124µs my $called = $cgc ? $cgc->($i) : caller($i);
35612900ns $i++;
357123µs my $caller = $cgc ? $cgc->($i) : caller($i);
358
359122µs if (!defined($caller)) {
360 my @caller = $cgc ? $cgc->($i) : caller($i);
361 if (@caller) {
362 # if there's no package but there is other caller info, then
363 # the package has been deleted - treat this as a valid package
364 # in this case
365 redo if defined($called) && $CarpInternal{$called};
366 redo unless 0 > --$lvl;
367 last;
368 }
369 else {
370 return 0;
371 }
372 }
373124µs redo if $Internal{$caller};
37462µs redo if $CarpInternal{$caller};
3753600ns redo if $CarpInternal{$called};
37633µs342µs redo if trusts( $called, $caller, $cache );
# spent 42µs making 3 calls to Carp::trusts, avg 14µs/call
37733µs324µs redo if trusts( $caller, $called, $cache );
# spent 24µs making 3 calls to Carp::trusts, avg 8µs/call
37832µs redo unless 0 > --$lvl;
379 }
38039µs return $i - 1;
381}
382
383
# spent 398µs (16+382) within Carp::shortmess_heavy which was called 3 times, avg 133µs/call: # 3 times (16µs+382µs) by Carp::shortmess at line 97, avg 133µs/call
sub shortmess_heavy {
3843500ns return longmess_heavy(@_) if $Verbose;
38531µs return @_ if ref( $_[0] ); # don't break references as exceptions
38633µs3133µs my $i = short_error_loc();
# spent 133µs making 3 calls to Carp::short_error_loc, avg 44µs/call
38738µs3249µs if ($i) {
# spent 249µs making 3 calls to Carp::ret_summary, avg 83µs/call
388 ret_summary( $i, @_ );
389 }
390 else {
391 longmess_heavy(@_);
392 }
393}
394
395# If a string is too long, trims it with ...
396
# spent 9µs within Carp::str_len_trim which was called 6 times, avg 1µs/call: # 6 times (9µs+0s) by Carp::format_arg at line 195, avg 1µs/call
sub str_len_trim {
39761µs my $str = shift;
39861µs my $max = shift || 0;
39962µs if ( 2 < $max and $max < length($str) ) {
400 substr( $str, $max - 3 ) = '...';
401 }
402610µs return $str;
403}
404
405# Takes two packages and an optional cache. Says whether the
406# first inherits from the second.
407#
408# Recursive versions of this have to work to avoid certain
409# possible endless loops, and when following long chains of
410# inheritance are less efficient.
411
# spent 66µs (23+43) within Carp::trusts which was called 6 times, avg 11µs/call: # 3 times (14µs+27µs) by Carp::short_error_loc at line 376, avg 14µs/call # 3 times (8µs+16µs) by Carp::short_error_loc at line 377, avg 8µs/call
sub trusts {
41261µs my $child = shift;
4136400ns my $parent = shift;
4146700ns my $cache = shift;
41564µs643µs my ( $known, $partial ) = get_status( $cache, $child );
# spent 43µs making 6 calls to Carp::get_status, avg 7µs/call
416
417 # Figure out consequences until we have an answer
41862µs while ( @$partial and not exists $known->{$parent} ) {
419 my $anc = shift @$partial;
420 next if exists $known->{$anc};
421 $known->{$anc}++;
422 my ( $anc_knows, $anc_partial ) = get_status( $cache, $anc );
423 my @found = keys %$anc_knows;
424 @$known{@found} = ();
425 push @$partial, @$anc_partial;
426 }
427611µs return exists $known->{$parent};
428}
429
430# Takes a package and gives a list of those trusted directly
431
# spent 16µs within Carp::trusts_directly which was called 6 times, avg 3µs/call: # 6 times (16µs+0s) by Carp::get_status at line 223, avg 3µs/call
sub trusts_directly {
4326800ns my $class = shift;
433222µs224µs
# spent 15µs (6+9) within Carp::BEGIN@433 which was called: # once (6µs+9µs) by Module::Pluggable::Object::BEGIN@7 at line 433
no strict 'refs';
# spent 15µs making 1 call to Carp::BEGIN@433 # spent 9µs making 1 call to strict::unimport
434255µs238µs
# spent 22µs (7+15) within Carp::BEGIN@434 which was called: # once (7µs+15µs) by Module::Pluggable::Object::BEGIN@7 at line 434
no warnings 'once';
# spent 22µs making 1 call to Carp::BEGIN@434 # spent 15µs making 1 call to warnings::unimport
435 return @{"$class\::CARP_NOT"}
436 ? @{"$class\::CARP_NOT"}
437621µs : @{"$class\::ISA"};
438}
439
4401600nsif(!defined($warnings::VERSION) ||
441332µs222µs
# spent 14µs (6+8) within Carp::BEGIN@441 which was called: # once (6µs+8µs) by Module::Pluggable::Object::BEGIN@7 at line 441
do { no warnings "numeric"; $warnings::VERSION < 1.03 }) {
# spent 14µs making 1 call to Carp::BEGIN@441 # spent 8µs making 1 call to warnings::unimport
442 # Very old versions of warnings.pm import from Carp. This can go
443 # wrong due to the circular dependency. If Carp is invoked before
444 # warnings, then Carp starts by loading warnings, then warnings
445 # tries to import from Carp, and gets nothing because Carp is in
446 # the process of loading and hasn't defined its import method yet.
447 # So we work around that by manually exporting to warnings here.
448247µs220µs
# spent 12µs (5+7) within Carp::BEGIN@448 which was called: # once (5µs+7µs) by Module::Pluggable::Object::BEGIN@7 at line 448
no strict "refs";
# spent 12µs making 1 call to Carp::BEGIN@448 # spent 7µs making 1 call to strict::unimport
449 *{"warnings::$_"} = \&$_ foreach @EXPORT;
450}
451
45217µs1;
453
454__END__
 
# spent 8µs within Carp::CORE:match which was called 6 times, avg 1µs/call: # 6 times (8µs+0s) by Carp::format_arg at line 202, avg 1µs/call
sub Carp::CORE:match; # opcode
# spent 10µs within Carp::CORE:subst which was called 12 times, avg 875ns/call: # 6 times (8µs+0s) by Carp::format_arg at line 212, avg 1µs/call # 6 times (2µs+0s) by Carp::format_arg at line 194, avg 333ns/call
sub Carp::CORE:subst; # opcode