Profile of constant.pm

Filename	/usr/share/perl/5.18/constant.pm
Statements	Executed 99 statements in 1.34ms

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
3	3	2	104µs	133µs	constant::::importconstant::import
1	1	1	19µs	19µs	constant::::BEGIN@2constant::BEGIN@2
1	1	1	18µs	18µs	constant::::BEGIN@24constant::BEGIN@24
3	1	1	10µs	10µs	constant::::CORE:matchconstant::CORE:match (opcode)
1	1	1	10µs	25µs	constant::::BEGIN@28constant::BEGIN@28
1	1	1	9µs	23µs	constant::::BEGIN@116constant::BEGIN@116
1	1	1	9µs	31µs	constant::::BEGIN@3constant::BEGIN@3
1	1	1	8µs	22µs	constant::::BEGIN@54constant::BEGIN@54
1	1	1	8µs	112µs	constant::::BEGIN@4constant::BEGIN@4
1	1	1	8µs	47µs	constant::::BEGIN@6constant::BEGIN@6
3	1	1	6µs	6µs	constant::::CORE:regcompconstant::CORE:regcomp (opcode)
3	3	1	5µs	5µs	constant::::CORE:qrconstant::CORE:qr (opcode)
0	0	0	0s	0s	constant::::__ANON__[:140]constant::__ANON__[:140]
0	0	0	0s	0s	constant::::__ANON__[:144]constant::__ANON__[:144]
0	0	0	0s	0s	constant::::__ANON__[:146]constant::__ANON__[:146]
0	0	0	0s	0s	constant::::__ANON__[:30]constant::__ANON__[:30]
0	0	0	0s	0s	constant::::__ANON__[:33]constant::__ANON__[:33]

Call graph for these subroutines as a Graphviz dot language file.

Line	State ments	Time on line	Calls	Time in subs	Code
1					package constant;
2	2	51µs	1	19µs	# spent 19µs within constant::BEGIN@2 which was called: # once (19µs+0s) by Try::Tiny::ScopeGuard::BEGIN@144 at line 2 use 5.008; # spent 19µs making 1 call to constant::BEGIN@2
3	2	29µs	2	53µs	# spent 31µs (9+22) within constant::BEGIN@3 which was called: # once (9µs+22µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 3 use strict; # spent 31µs making 1 call to constant::BEGIN@3 # spent 22µs making 1 call to strict::import
4	2	45µs	2	216µs	# spent 112µs (8+104) within constant::BEGIN@4 which was called: # once (8µs+104µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 4 use warnings::register; # spent 112µs making 1 call to constant::BEGIN@4 # spent 104µs making 1 call to warnings::register::import
5
6	2	181µs	2	86µs	# spent 47µs (8+39) within constant::BEGIN@6 which was called: # once (8µs+39µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 6 use vars qw($VERSION %declared); # spent 47µs making 1 call to constant::BEGIN@6 # spent 39µs making 1 call to vars::import
7	1	700ns			$VERSION = '1.27';
8
9					#=======================================================================
10
11					# Some names are evil choices.
12	1	8µs			my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD };
13	1	2µs			$keywords{UNITCHECK}++ if $] > 5.009;
14
15	1	7µs			my %forced_into_main = map +($_, 1),
16					qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG };
17
18	1	6µs			my %forbidden = (%keywords, %forced_into_main);
19
20	1	10µs	1	3µs	my $normal_constant_name = qr/^_?[^\W_0-9]\w*\z/; # spent 3µs making 1 call to constant::CORE:qr
21	1	4µs	1	1µs	my $tolerable = qr/^[A-Za-z_]\w*\z/; # spent 1µs making 1 call to constant::CORE:qr
22	1	3µs	1	800ns	my $boolean = qr/^[01]?\z/; # spent 800ns making 1 call to constant::CORE:qr
23
24					# spent 18µs within constant::BEGIN@24 which was called: # once (18µs+0s) by Try::Tiny::ScopeGuard::BEGIN@144 at line 34 BEGIN {
25					# We'd like to do use constant _CAN_PCS => $] > 5.009002
26					# but that's a bit tricky before we load the constant module :-)
27					# By doing this, we save 1 run time check for every call to import.
28	2	97µs	2	40µs	# spent 25µs (10+16) within constant::BEGIN@28 which was called: # once (10µs+16µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 28 no strict 'refs'; # spent 25µs making 1 call to constant::BEGIN@28 # spent 16µs making 1 call to strict::unimport
29	1	2µs			my $const = $] > 5.009002;
30	1	8µs			*_CAN_PCS = sub () {$const};
31
32	1	700ns			my $downgrade = $] < 5.015004; # && $] >= 5.008
33	1	8µs			*_DOWNGRADE = sub () { $downgrade };
34	1	89µs	1	18µs	} # spent 18µs making 1 call to constant::BEGIN@24
35
36					#=======================================================================
37					# import() - import symbols into user's namespace
38					#
39					# What we actually do is define a function in the caller's namespace
40					# which returns the value. The function we create will normally
41					# be inlined as a constant, thereby avoiding further sub calling
42					# overhead.
43					#=======================================================================
44					# spent 133µs (104+29) within constant::import which was called 3 times, avg 44µs/call: # once (44µs+13µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 144 of Try/Tiny.pm # once (32µs+9µs) by namespace::clean::_Util::BEGIN@18 at line 18 of namespace/clean/_Util.pm # once (28µs+7µs) by namespace::clean::_Util::BEGIN@19 at line 19 of namespace/clean/_Util.pm sub import {
45	3	2µs			my $class = shift;
46	3	2µs			return unless @_; # Ignore 'use constant;'
47	3	600ns			my $constants;
48	3	2µs			my $multiple = ref $_[0];
49	3	2µs			my $pkg = caller;
50	3	500ns			my $flush_mro;
51	3	300ns			my $symtab;
52
53	3	2µs			if (_CAN_PCS) {
54	2	336µs	2	36µs	# spent 22µs (8+14) within constant::BEGIN@54 which was called: # once (8µs+14µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 54 no strict 'refs'; # spent 22µs making 1 call to constant::BEGIN@54 # spent 14µs making 1 call to strict::unimport
55	3	6µs			$symtab = \%{$pkg . '::'};
56					};
57
58	3	2µs			if ( $multiple ) {
59					if (ref $_[0] ne 'HASH') {
60					require Carp;
61					Carp::croak("Invalid reference type '".ref(shift)."' not 'HASH'");
62					}
63					$constants = shift;
64					} else {
65	3	1µs			unless (defined $_[0]) {
66					require Carp;
67					Carp::croak("Can't use undef as constant name");
68					}
69	3	5µs			$constants->{+shift} = undef;
70					}
71
72	3	6µs			foreach my $name ( keys %$constants ) {
73					# Normal constant name
74	3	37µs	6	16µs	if ($name =~ $normal_constant_name and !$forbidden{$name}) { # spent 10µs making 3 calls to constant::CORE:match, avg 3µs/call # spent 6µs making 3 calls to constant::CORE:regcomp, avg 2µs/call
75					# Everything is okay
76
77					# Name forced into main, but we're not in main. Fatal.
78					} elsif ($forced_into_main{$name} and $pkg ne 'main') {
79					require Carp;
80					Carp::croak("Constant name '$name' is forced into main::");
81
82					# Starts with double underscore. Fatal.
83					} elsif ($name =~ /^__/) {
84					require Carp;
85					Carp::croak("Constant name '$name' begins with '__'");
86
87					# Maybe the name is tolerable
88					} elsif ($name =~ $tolerable) {
89					# Then we'll warn only if you've asked for warnings
90					if (warnings::enabled()) {
91					if ($keywords{$name}) {
92					warnings::warn("Constant name '$name' is a Perl keyword");
93					} elsif ($forced_into_main{$name}) {
94					warnings::warn("Constant name '$name' is " .
95					"forced into package main::");
96					}
97					}
98
99					# Looks like a boolean
100					# use constant FRED == fred;
101					} elsif ($name =~ $boolean) {
102					require Carp;
103					if (@_) {
104					Carp::croak("Constant name '$name' is invalid");
105					} else {
106					Carp::croak("Constant name looks like boolean value");
107					}
108
109					} else {
110					# Must have bad characters
111					require Carp;
112					Carp::croak("Constant name '$name' has invalid characters");
113					}
114
115					{
116	5	310µs	2	37µs	# spent 23µs (9+14) within constant::BEGIN@116 which was called: # once (9µs+14µs) by Try::Tiny::ScopeGuard::BEGIN@144 at line 116 no strict 'refs'; # spent 23µs making 1 call to constant::BEGIN@116 # spent 14µs making 1 call to strict::unimport
117	3	3µs			my $full_name = "${pkg}::$name";
118	3	4µs			$declared{$full_name}++;
119	3	3µs			if ($multiple \|\| @_ == 1) {
120	3	2µs			my $scalar = $multiple ? $constants->{$name} : $_[0];
121
122					if (_DOWNGRADE) { # for 5.8 to 5.14
123					# Work around perl bug #31991: Sub names (actually glob
124					# names in general) ignore the UTF8 flag. So we have to
125					# turn it off to get the "right" symbol table entry.
126					utf8::is_utf8 $name and utf8::encode $name;
127					}
128
129					# The constant serves to optimise this entire block out on
130					# 5.8 and earlier.
131	3	3µs			if (_CAN_PCS && $symtab && !exists $symtab->{$name}) {
132					# No typeglob yet, so we can use a reference as space-
133					# efficient proxy for a constant subroutine
134					# The check in Perl_ck_rvconst knows that inlinable
135					# constants from cv_const_sv are read only. So we have to:
136	3	23µs	3	8µs	Internals::SvREADONLY($scalar, 1); # spent 8µs making 3 calls to Internals::SvREADONLY, avg 2µs/call
137	3	2µs			$symtab->{$name} = \$scalar;
138	3	2µs			++$flush_mro;
139					} else {
140					*$full_name = sub () { $scalar };
141					}
142					} elsif (@_) {
143					my @list = @_;
144					*$full_name = sub () { @list };
145					} else {
146					*$full_name = sub () { };
147					}
148					}
149					}
150					# Flush the cache exactly once if we make any direct symbol table changes.
151	3	27µs	3	6µs	mro::method_changed_in($pkg) if _CAN_PCS && $flush_mro; # spent 6µs making 3 calls to mro::method_changed_in, avg 2µs/call
152					}
153
154	1	8µs			1;
155
156					__END__

					# spent 10µs within constant::CORE:match which was called 3 times, avg 3µs/call: # 3 times (10µs+0s) by constant::import at line 74, avg 3µs/call sub constant::CORE:match; # opcode
					# spent 5µs within constant::CORE:qr which was called 3 times, avg 2µs/call: # once (3µs+0s) by Try::Tiny::ScopeGuard::BEGIN@144 at line 20 # once (1µs+0s) by Try::Tiny::ScopeGuard::BEGIN@144 at line 21 # once (800ns+0s) by Try::Tiny::ScopeGuard::BEGIN@144 at line 22 sub constant::CORE:qr; # opcode
					# spent 6µs within constant::CORE:regcomp which was called 3 times, avg 2µs/call: # 3 times (6µs+0s) by constant::import at line 74, avg 2µs/call sub constant::CORE:regcomp; # opcode