Profile of overload.pm

← Index
NYTProf Performance Profile «line view»
For t/optimization.t
Run on Thu Jan 8 22:47:42 2015
Reported on Thu Jan 8 22:48:05 2015

Filename | /home/ss5/perl5/perlbrew/perls/tapper-perl/lib/5.16.3/overload.pm
Statements | Executed 128 statements in 951µs

Subroutines
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
1 | 1 | 1 | 402µs | 464µs | overload::::BEGIN@85overload::BEGIN@85
5 | 1 | 1 | 144µs | 146µs | overload::::OVERLOADoverload::OVERLOAD
5 | 5 | 5 | 53µs | 198µs | overload::::importoverload::import
1 | 1 | 1 | 12µs | 19µs | overload::::BEGIN@116overload::BEGIN@116
1 | 1 | 1 | 11µs | 107µs | overload::::BEGIN@146overload::BEGIN@146
1 | 1 | 1 | 1µs | 1µs | overload::::CORE:matchoverload::CORE:match (opcode)
0 | 0 | 0 | 0s | 0s | overload::::AddrRefoverload::AddrRef
0 | 0 | 0 | 0s | 0s | overload::::Methodoverload::Method
0 | 0 | 0 | 0s | 0s | overload::::Overloadedoverload::Overloaded
0 | 0 | 0 | 0s | 0s | overload::::OverloadedStringifyoverload::OverloadedStringify
0 | 0 | 0 | 0s | 0s | overload::::constantoverload::constant
0 | 0 | 0 | 0s | 0s | overload::::mycanoverload::mycan
0 | 0 | 0 | 0s | 0s | overload::::niloverload::nil
0 | 0 | 0 | 0s | 0s | overload::::ov_methodoverload::ov_method
0 | 0 | 0 | 0s | 0s | overload::::remove_constantoverload::remove_constant
0 | 0 | 0 | 0s | 0s | overload::::unimportoverload::unimport

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

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | package overload;
2 |  |  |  |  |
3 | 1 | 600ns |  |  | our $VERSION = '1.18';
4 |  |  |  |  |
5 | 1 | 9µs |  |  | %ops = (
6 |  |  |  |  | with_assign => "+ - * / % ** << >> x .",
7 |  |  |  |  | assign => "+= -= *= /= %= **= <<= >>= x= .=",
8 |  |  |  |  | num_comparison => "< <= > >= == !=",
9 |  |  |  |  | '3way_comparison' => "<=> cmp",
10 |  |  |  |  | str_comparison => "lt le gt ge eq ne",
11 |  |  |  |  | binary => '& &= | |= ^ ^=',
12 |  |  |  |  | unary => "neg ! ~",
13 |  |  |  |  | mutators => '++ --',
14 |  |  |  |  | func => "atan2 cos sin exp abs log sqrt int",
15 |  |  |  |  | conversion => 'bool "" 0+ qr',
16 |  |  |  |  | iterators => '<>',
17 |  |  |  |  | filetest => "-X",
18 |  |  |  |  | dereferencing => '${} @{} %{} &{} *{}',
19 |  |  |  |  | matching => '~~',
20 |  |  |  |  | special => 'nomethod fallback =',
21 |  |  |  |  | );
22 |  |  |  |  |
23 | 1 | 300ns |  |  | my %ops_seen;
24 | 1 | 4µs |  |  | for $category (keys %ops) {
25 | 15 | 68µs |  |  | $ops_seen{$_}++ for (split /\s+/, $ops{$category});
26 |  |  |  |  | }
27 |  |  |  |  |
28 |  |  |  |  | sub nil {}
29 |  |  |  |  |
30 |  |  |  |  | # spent 146µs (144+1) within overload::OVERLOAD which was called 5 times, avg 29µs/call: # 5 times (144µs+1µs) by overload::import at line 59, avg 29µs/call sub OVERLOAD {
31 | 5 | 2µs |  |  | $package = shift;
32 | 5 | 12µs |  |  | my %arg = @_;
33 | 5 | 2µs |  |  | my ($sub, $fb);
34 | 5 | 25µs |  |  | $ {$package . "::OVERLOAD"}{dummy}++; # Register with magic by touching.
35 | 5 | 10µs |  |  | $fb = ${$package . "::()"}; # preserve old fallback value RT#68196
36 | 5 | 12µs |  |  | *{$package . "::()"} = \&nil; # Make it findable via fetchmethod.
37 | 5 | 11µs |  |  | for (keys %arg) {
38 | 11 | 12µs |  |  | if ($_ eq 'fallback') {
39 |  |  |  |  | $fb = $arg{$_};
40 |  |  |  |  | } else {
41 | 8 | 5µs |  |  | warnings::warnif("overload arg '$_' is invalid")
42 |  |  |  |  | unless $ops_seen{$_};
43 | 8 | 4µs |  |  | $sub = $arg{$_};
44 | 8 | 12µs | 1 | 1µs | if (not ref $sub and $sub !~ /::/) { # spent 1µs making 1 call to overload::CORE:match
45 | 1 | 3µs |  |  | $ {$package . "::(" . $_} = $sub;
46 | 1 | 900ns |  |  | $sub = \&nil;
47 |  |  |  |  | }
48 |  |  |  |  | #print STDERR "Setting '$ {'package'}::\cO$_' to \\&'$sub'.\n";
49 | 8 | 20µs |  |  | *{$package . "::(" . $_} = \&{ $sub };
50 |  |  |  |  | }
51 |  |  |  |  | }
52 | 5 | 29µs |  |  | ${$package . "::()"} = $fb; # Make it findable too (fallback only).
53 |  |  |  |  | }
54 |  |  |  |  |
55 |  |  |  |  | # spent 198µs (53+146) within overload::import which was called 5 times, avg 40µs/call: # once (8µs+39µs) by Exception::Class::Base::BEGIN@35 at line 35 of Exception/Class/Base.pm # once (11µs+33µs) by Test::Deep::Cmp::BEGIN@7 at line 7 of Test/Deep/Cmp.pm # once (12µs+27µs) by Devel::StackTrace::BEGIN@16 at line 16 of Devel/StackTrace.pm # once (12µs+25µs) by Text::Balanced::ErrorMsg::BEGIN@1021 at line 1021 of Text/Balanced.pm # once (9µs+21µs) by Data::DPath::Path::BEGIN@1.9 at line 1 of (eval 37)[lib/Data/DPath/Path.pm:55] sub import {
56 | 5 | 9µs |  |  | $package = (caller())[0];
57 |  |  |  |  | # *{$package . "::OVERLOAD"} = \&OVERLOAD;
58 | 5 | 2µs |  |  | shift;
59 | 5 | 38µs | 5 | 146µs | $package->overload::OVERLOAD(@_); # spent 146µs making 5 calls to overload::OVERLOAD, avg 29µs/call
60 |  |  |  |  | }
61 |  |  |  |  |
62 |  |  |  |  | sub unimport {
63 |  |  |  |  | $package = (caller())[0];
64 |  |  |  |  | ${$package . "::OVERLOAD"}{dummy}++; # Upgrade the table
65 |  |  |  |  | shift;
66 |  |  |  |  | for (@_) {
67 |  |  |  |  | if ($_ eq 'fallback') {
68 |  |  |  |  | undef $ {$package . "::()"};
69 |  |  |  |  | } else {
70 |  |  |  |  | delete $ {$package . "::"}{"(" . $_};
71 |  |  |  |  | }
72 |  |  |  |  | }
73 |  |  |  |  | }
74 |  |  |  |  |
75 |  |  |  |  | sub Overloaded {
76 |  |  |  |  | my $package = shift;
77 |  |  |  |  | $package = ref $package if ref $package;
78 |  |  |  |  | mycan ($package, '()');
79 |  |  |  |  | }
80 |  |  |  |  |
81 |  |  |  |  | sub ov_method {
82 |  |  |  |  | my $globref = shift;
83 |  |  |  |  | return undef unless $globref;
84 |  |  |  |  | my $sub = \&{*$globref};
85 | 2 | 263µs | 2 | 476µs | # spent 464µs (402+62) within overload::BEGIN@85 which was called: # once (402µs+62µs) by main::BEGIN@7 at line 85 no overloading; # spent 464µs making 1 call to overload::BEGIN@85 # spent 12µs making 1 call to overloading::unimport
86 |  |  |  |  | return $sub if !ref $sub or $sub != \&nil;
87 |  |  |  |  | return shift->can($ {*$globref});
88 |  |  |  |  | }
89 |  |  |  |  |
90 |  |  |  |  | sub OverloadedStringify {
91 |  |  |  |  | my $package = shift;
92 |  |  |  |  | $package = ref $package if ref $package;
93 |  |  |  |  | #$package->can('(""')
94 |  |  |  |  | ov_method mycan($package, '(""'), $package
95 |  |  |  |  | or ov_method mycan($package, '(0+'), $package
96 |  |  |  |  | or ov_method mycan($package, '(bool'), $package
97 |  |  |  |  | or ov_method mycan($package, '(nomethod'), $package;
98 |  |  |  |  | }
99 |  |  |  |  |
100 |  |  |  |  | sub Method {
101 |  |  |  |  | my $package = shift;
102 |  |  |  |  | if(ref $package) {
103 |  |  |  |  | local $@;
104 |  |  |  |  | local $!;
105 |  |  |  |  | require Scalar::Util;
106 |  |  |  |  | $package = Scalar::Util::blessed($package);
107 |  |  |  |  | return undef if !defined $package;
108 |  |  |  |  | }
109 |  |  |  |  | #my $meth = $package->can('(' . shift);
110 |  |  |  |  | ov_method mycan($package, '(' . shift), $package;
111 |  |  |  |  | #return $meth if $meth ne \&nil;
112 |  |  |  |  | #return $ {*{$meth}};
113 |  |  |  |  | }
114 |  |  |  |  |
115 |  |  |  |  | sub AddrRef {
116 | 2 | 158µs | 2 | 27µs | # spent 19µs (12+8) within overload::BEGIN@116 which was called: # once (12µs+8µs) by main::BEGIN@7 at line 116 no overloading; # spent 19µs making 1 call to overload::BEGIN@116 # spent 8µs making 1 call to overloading::unimport
117 |  |  |  |  | "$_[0]";
118 |  |  |  |  | }
119 |  |  |  |  |
120 | 1 | 2µs |  |  | *StrVal = *AddrRef;
121 |  |  |  |  |
122 |  |  |  |  | sub mycan { # Real can would leave stubs.
123 |  |  |  |  | my ($package, $meth) = @_;
124 |  |  |  |  |
125 |  |  |  |  | local $@;
126 |  |  |  |  | local $!;
127 |  |  |  |  | require mro;
128 |  |  |  |  |
129 |  |  |  |  | my $mro = mro::get_linear_isa($package);
130 |  |  |  |  | foreach my $p (@$mro) {
131 |  |  |  |  | my $fqmeth = $p . q{::} . $meth;
132 |  |  |  |  | return \*{$fqmeth} if defined &{$fqmeth};
133 |  |  |  |  | }
134 |  |  |  |  |
135 |  |  |  |  | return undef;
136 |  |  |  |  | }
137 |  |  |  |  |
138 | 1 | 2µs |  |  | %constants = (
139 |  |  |  |  | 'integer' => 0x1000, # HINT_NEW_INTEGER
140 |  |  |  |  | 'float' => 0x2000, # HINT_NEW_FLOAT
141 |  |  |  |  | 'binary' => 0x4000, # HINT_NEW_BINARY
142 |  |  |  |  | 'q' => 0x8000, # HINT_NEW_STRING
143 |  |  |  |  | 'qr' => 0x10000, # HINT_NEW_RE
144 |  |  |  |  | );
145 |  |  |  |  |
146 | 2 | 225µs | 2 | 203µs | # spent 107µs (11+96) within overload::BEGIN@146 which was called: # once (11µs+96µs) by main::BEGIN@7 at line 146 use warnings::register; # spent 107µs making 1 call to overload::BEGIN@146 # spent 96µs making 1 call to warnings::register::import
147 |  |  |  |  | sub constant {
148 |  |  |  |  | # Arguments: what, sub
149 |  |  |  |  | while (@_) {
150 |  |  |  |  | if (@_ == 1) {
151 |  |  |  |  | warnings::warnif ("Odd number of arguments for overload::constant");
152 |  |  |  |  | last;
153 |  |  |  |  | }
154 |  |  |  |  | elsif (!exists $constants {$_ [0]}) {
155 |  |  |  |  | warnings::warnif ("'$_[0]' is not an overloadable type");
156 |  |  |  |  | }
157 |  |  |  |  | elsif (!ref $_ [1] || "$_[1]" !~ /(^|=)CODE\(0x[0-9a-f]+\)$/) {
158 |  |  |  |  | # Can't use C<ref $_[1] eq "CODE"> above as code references can be
159 |  |  |  |  | # blessed, and C<ref> would return the package the ref is blessed into.
160 |  |  |  |  | if (warnings::enabled) {
161 |  |  |  |  | $_ [1] = "undef" unless defined $_ [1];
162 |  |  |  |  | warnings::warn ("'$_[1]' is not a code reference");
163 |  |  |  |  | }
164 |  |  |  |  | }
165 |  |  |  |  | else {
166 |  |  |  |  | $^H{$_[0]} = $_[1];
167 |  |  |  |  | $^H |= $constants{$_[0]};
168 |  |  |  |  | }
169 |  |  |  |  | shift, shift;
170 |  |  |  |  | }
171 |  |  |  |  | }
172 |  |  |  |  |
173 |  |  |  |  | sub remove_constant {
174 |  |  |  |  | # Arguments: what, sub
175 |  |  |  |  | while (@_) {
176 |  |  |  |  | delete $^H{$_[0]};
177 |  |  |  |  | $^H &= ~ $constants{$_[0]};
178 |  |  |  |  | shift, shift;
179 |  |  |  |  | }
180 |  |  |  |  | }
181 |  |  |  |  |
182 | 1 | 12µs |  |  | 1;
183 |  |  |  |  |
184 |  |  |  |  | __END__
|  |  |  |  | # spent 1µs within overload::CORE:match which was called: # once (1µs+0s) by overload::OVERLOAD at line 44 sub overload::CORE:match; # opcode