Profile of /usr/local/lib/perl5/5.10.1/darwin-2level/Scalar/Util.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For 01.HTTP.t
Run on Tue May 4 15:25:55 2010
Reported on Tue May 4 15:26:12 2010

File | /usr/local/lib/perl5/5.10.1/darwin-2level/Scalar/Util.pm
Statements Executed | 14
Statement Execution Time | 1.24ms

Subroutines — ordered by exclusive time
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
2289 | 22 | 19 | 1.32ms | 1.32ms | Scalar::Util::::blessedScalar::Util::blessed (xsub)
718 | 8 | 8 | 679µs | 679µs | Scalar::Util::::weakenScalar::Util::weaken (xsub)
1 | 1 | 1 | 426µs | 888µs | Scalar::Util::::BEGIN@10Scalar::Util::BEGIN@10
202 | 6 | 5 | 128µs | 128µs | Scalar::Util::::reftypeScalar::Util::reftype (xsub)
29 | 1 | 2 | 34µs | 34µs | Scalar::Util::::looks_like_numberScalar::Util::looks_like_number (xsub)
1 | 1 | 1 | 15µs | 18µs | Scalar::Util::::BEGIN@9Scalar::Util::BEGIN@9
2 | 1 | 2 | 7µs | 7µs | Scalar::Util::::refaddrScalar::Util::refaddr (xsub)
0 | 0 | 0 | 0s | 0s | Scalar::Util::::export_failScalar::Util::export_fail
0 | 0 | 0 | 0s | 0s | Scalar::Util::::openhandleScalar::Util::openhandle

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

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | # Scalar::Util.pm
2 |  |  |  |  | #
3 |  |  |  |  | # Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
4 |  |  |  |  | # This program is free software; you can redistribute it and/or
5 |  |  |  |  | # modify it under the same terms as Perl itself.
6 |  |  |  |  |
7 |  |  |  |  | package Scalar::Util;
8 |  |  |  |  |
9 | 3 | 28µs | 2 | 22µs | # spent 18µs (15+3) within Scalar::Util::BEGIN@9 which was called # once (15µs+3µs) by Moose::BEGIN@11 at line 9 use strict; # spent 18µs making 1 call to Scalar::Util::BEGIN@9 # spent 3µs making 1 call to strict::import
10 | 3 | 1.03ms | 2 | 963µs | # spent 888µs (426+462) within Scalar::Util::BEGIN@10 which was called # once (426µs+462µs) by Moose::BEGIN@11 at line 10 use vars qw(@ISA @EXPORT_OK $VERSION @EXPORT_FAIL); # spent 888µs making 1 call to Scalar::Util::BEGIN@10 # spent 76µs making 1 call to vars::import
11 | 1 | 2µs |  |  | require Exporter;
12 | 1 | 141µs |  |  | require List::Util; # List::Util loads the XS
13 |  |  |  |  |
14 | 1 | 6µs |  |  | @ISA = qw(Exporter);
15 | 1 | 2µs |  |  | @EXPORT_OK = qw(blessed dualvar reftype weaken isweak tainted readonly openhandle refaddr isvstring looks_like_number set_prototype);
16 | 1 | 300ns |  |  | $VERSION = "1.23";
17 | 1 | 18µs |  |  | $VERSION = eval $VERSION;
18 |  |  |  |  |
19 | 1 | 200ns |  |  | unless (defined &dualvar) {
20 |  |  |  |  | # Load Pure Perl version if XS not loaded
21 |  |  |  |  | require Scalar::Util::PP;
22 |  |  |  |  | Scalar::Util::PP->import;
23 |  |  |  |  | push @EXPORT_FAIL, qw(weaken isweak dualvar isvstring set_prototype);
24 |  |  |  |  | }
25 |  |  |  |  |
26 |  |  |  |  | sub export_fail {
27 |  |  |  |  | if (grep { /dualvar/ } @EXPORT_FAIL) { # no XS loaded
28 |  |  |  |  | my $pat = join("|", @EXPORT_FAIL);
29 |  |  |  |  | if (my ($err) = grep { /^($pat)$/ } @_ ) {
30 |  |  |  |  | require Carp;
31 |  |  |  |  | Carp::croak("$err is only available with the XS version of Scalar::Util");
32 |  |  |  |  | }
33 |  |  |  |  | }
34 |  |  |  |  |
35 |  |  |  |  | if (grep { /^(weaken|isweak)$/ } @_ ) {
36 |  |  |  |  | require Carp;
37 |  |  |  |  | Carp::croak("Weak references are not implemented in the version of perl");
38 |  |  |  |  | }
39 |  |  |  |  |
40 |  |  |  |  | if (grep { /^(isvstring)$/ } @_ ) {
41 |  |  |  |  | require Carp;
42 |  |  |  |  | Carp::croak("Vstrings are not implemented in the version of perl");
43 |  |  |  |  | }
44 |  |  |  |  |
45 |  |  |  |  | @_;
46 |  |  |  |  | }
47 |  |  |  |  |
48 |  |  |  |  | sub openhandle ($) {
49 |  |  |  |  | my $fh = shift;
50 |  |  |  |  | my $rt = reftype($fh) || '';
51 |  |  |  |  |
52 |  |  |  |  | return defined(fileno($fh)) ? $fh : undef
53 |  |  |  |  | if $rt eq 'IO';
54 |  |  |  |  |
55 |  |  |  |  | if (reftype(\$fh) eq 'GLOB') { # handle openhandle(*DATA)
56 |  |  |  |  | $fh = \(my $tmp=$fh);
57 |  |  |  |  | }
58 |  |  |  |  | elsif ($rt ne 'GLOB') {
59 |  |  |  |  | return undef;
60 |  |  |  |  | }
61 |  |  |  |  |
62 |  |  |  |  | (tied(*$fh) or defined(fileno($fh)))
63 |  |  |  |  | ? $fh : undef;
64 |  |  |  |  | }
65 |  |  |  |  |
66 | 1 | 13µs |  |  | 1;
67 |  |  |  |  |
68 |  |  |  |  | __END__
69 |  |  |  |  |
70 |  |  |  |  | =head1 NAME
71 |  |  |  |  |
72 |  |  |  |  | Scalar::Util - A selection of general-utility scalar subroutines
73 |  |  |  |  |
74 |  |  |  |  | =head1 SYNOPSIS
75 |  |  |  |  |
76 |  |  |  |  | use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
77 |  |  |  |  | weaken isvstring looks_like_number set_prototype);
78 |  |  |  |  | # and other useful utils appearing below
79 |  |  |  |  |
80 |  |  |  |  | =head1 DESCRIPTION
81 |  |  |  |  |
82 |  |  |  |  | C<Scalar::Util> contains a selection of subroutines that people have
83 |  |  |  |  | expressed would be nice to have in the perl core, but the usage would
84 |  |  |  |  | not really be high enough to warrant the use of a keyword, and the size
85 |  |  |  |  | so small such that being individual extensions would be wasteful.
86 |  |  |  |  |
87 |  |  |  |  | By default C<Scalar::Util> does not export any subroutines. The
88 |  |  |  |  | subroutines defined are
89 |  |  |  |  |
90 |  |  |  |  | =over 4
91 |  |  |  |  |
92 |  |  |  |  | =item blessed EXPR
93 |  |  |  |  |
94 |  |  |  |  | If EXPR evaluates to a blessed reference the name of the package
95 |  |  |  |  | that it is blessed into is returned. Otherwise C<undef> is returned.
96 |  |  |  |  |
97 |  |  |  |  | $scalar = "foo";
98 |  |  |  |  | $class = blessed $scalar; # undef
99 |  |  |  |  |
100 |  |  |  |  | $ref = [];
101 |  |  |  |  | $class = blessed $ref; # undef
102 |  |  |  |  |
103 |  |  |  |  | $obj = bless [], "Foo";
104 |  |  |  |  | $class = blessed $obj; # "Foo"
105 |  |  |  |  |
106 |  |  |  |  | =item dualvar NUM, STRING
107 |  |  |  |  |
108 |  |  |  |  | Returns a scalar that has the value NUM in a numeric context and the
109 |  |  |  |  | value STRING in a string context.
110 |  |  |  |  |
111 |  |  |  |  | $foo = dualvar 10, "Hello";
112 |  |  |  |  | $num = $foo + 2; # 12
113 |  |  |  |  | $str = $foo . " world"; # Hello world
114 |  |  |  |  |
115 |  |  |  |  | =item isvstring EXPR
116 |  |  |  |  |
117 |  |  |  |  | If EXPR is a scalar which was coded as a vstring the result is true.
118 |  |  |  |  |
119 |  |  |  |  | $vs = v49.46.48;
120 |  |  |  |  | $fmt = isvstring($vs) ? "%vd" : "%s"; #true
121 |  |  |  |  | printf($fmt,$vs);
122 |  |  |  |  |
123 |  |  |  |  | =item isweak EXPR
124 |  |  |  |  |
125 |  |  |  |  | If EXPR is a scalar which is a weak reference the result is true.
126 |  |  |  |  |
127 |  |  |  |  | $ref = \$foo;
128 |  |  |  |  | $weak = isweak($ref); # false
129 |  |  |  |  | weaken($ref);
130 |  |  |  |  | $weak = isweak($ref); # true
131 |  |  |  |  |
132 |  |  |  |  | B<NOTE>: Copying a weak reference creates a normal, strong, reference.
133 |  |  |  |  |
134 |  |  |  |  | $copy = $ref;
135 |  |  |  |  | $weak = isweak($copy); # false
136 |  |  |  |  |
137 |  |  |  |  | =item looks_like_number EXPR
138 |  |  |  |  |
139 |  |  |  |  | Returns true if perl thinks EXPR is a number. See
140 |  |  |  |  | L<perlapi/looks_like_number>.
141 |  |  |  |  |
142 |  |  |  |  | =item openhandle FH
143 |  |  |  |  |
144 |  |  |  |  | Returns FH if FH may be used as a filehandle and is open, or FH is a tied
145 |  |  |  |  | handle. Otherwise C<undef> is returned.
146 |  |  |  |  |
147 |  |  |  |  | $fh = openhandle(*STDIN); # \*STDIN
148 |  |  |  |  | $fh = openhandle(\*STDIN); # \*STDIN
149 |  |  |  |  | $fh = openhandle(*NOTOPEN); # undef
150 |  |  |  |  | $fh = openhandle("scalar"); # undef
151 |  |  |  |  |
152 |  |  |  |  | =item readonly SCALAR
153 |  |  |  |  |
154 |  |  |  |  | Returns true if SCALAR is readonly.
155 |  |  |  |  |
156 |  |  |  |  | sub foo { readonly($_[0]) }
157 |  |  |  |  |
158 |  |  |  |  | $readonly = foo($bar); # false
159 |  |  |  |  | $readonly = foo(0); # true
160 |  |  |  |  |
161 |  |  |  |  | =item refaddr EXPR
162 |  |  |  |  |
163 |  |  |  |  | If EXPR evaluates to a reference the internal memory address of
164 |  |  |  |  | the referenced value is returned. Otherwise C<undef> is returned.
165 |  |  |  |  |
166 |  |  |  |  | $addr = refaddr "string"; # undef
167 |  |  |  |  | $addr = refaddr \$var; # eg 12345678
168 |  |  |  |  | $addr = refaddr []; # eg 23456784
169 |  |  |  |  |
170 |  |  |  |  | $obj = bless {}, "Foo";
171 |  |  |  |  | $addr = refaddr $obj; # eg 88123488
172 |  |  |  |  |
173 |  |  |  |  | =item reftype EXPR
174 |  |  |  |  |
175 |  |  |  |  | If EXPR evaluates to a reference the type of the variable referenced
176 |  |  |  |  | is returned. Otherwise C<undef> is returned.
177 |  |  |  |  |
178 |  |  |  |  | $type = reftype "string"; # undef
179 |  |  |  |  | $type = reftype \$var; # SCALAR
180 |  |  |  |  | $type = reftype []; # ARRAY
181 |  |  |  |  |
182 |  |  |  |  | $obj = bless {}, "Foo";
183 |  |  |  |  | $type = reftype $obj; # HASH
184 |  |  |  |  |
185 |  |  |  |  | =item set_prototype CODEREF, PROTOTYPE
186 |  |  |  |  |
187 |  |  |  |  | Sets the prototype of the given function, or deletes it if PROTOTYPE is
188 |  |  |  |  | undef. Returns the CODEREF.
189 |  |  |  |  |
190 |  |  |  |  | set_prototype \&foo, '$$';
191 |  |  |  |  |
192 |  |  |  |  | =item tainted EXPR
193 |  |  |  |  |
194 |  |  |  |  | Return true if the result of EXPR is tainted
195 |  |  |  |  |
196 |  |  |  |  | $taint = tainted("constant"); # false
197 |  |  |  |  | $taint = tainted($ENV{PWD}); # true if running under -T
198 |  |  |  |  |
199 |  |  |  |  | =item weaken REF
200 |  |  |  |  |
201 |  |  |  |  | REF will be turned into a weak reference. This means that it will not
202 |  |  |  |  | hold a reference count on the object it references. Also when the reference
203 |  |  |  |  | count on that object reaches zero, REF will be set to undef.
204 |  |  |  |  |
205 |  |  |  |  | This is useful for keeping copies of references , but you don't want to
206 |  |  |  |  | prevent the object being DESTROY-ed at its usual time.
207 |  |  |  |  |
208 |  |  |  |  | {
209 |  |  |  |  | my $var;
210 |  |  |  |  | $ref = \$var;
211 |  |  |  |  | weaken($ref); # Make $ref a weak reference
212 |  |  |  |  | }
213 |  |  |  |  | # $ref is now undef
214 |  |  |  |  |
215 |  |  |  |  | Note that if you take a copy of a scalar with a weakened reference,
216 |  |  |  |  | the copy will be a strong reference.
217 |  |  |  |  |
218 |  |  |  |  | my $var;
219 |  |  |  |  | my $foo = \$var;
220 |  |  |  |  | weaken($foo); # Make $foo a weak reference
221 |  |  |  |  | my $bar = $foo; # $bar is now a strong reference
222 |  |  |  |  |
223 |  |  |  |  | This may be less obvious in other situations, such as C<grep()>, for instance
224 |  |  |  |  | when grepping through a list of weakened references to objects that may have
225 |  |  |  |  | been destroyed already:
226 |  |  |  |  |
227 |  |  |  |  | @object = grep { defined } @object;
228 |  |  |  |  |
229 |  |  |  |  | This will indeed remove all references to destroyed objects, but the remaining
230 |  |  |  |  | references to objects will be strong, causing the remaining objects to never
231 |  |  |  |  | be destroyed because there is now always a strong reference to them in the
232 |  |  |  |  | @object array.
233 |  |  |  |  |
234 |  |  |  |  | =back
235 |  |  |  |  |
236 |  |  |  |  | =head1 DIAGNOSTICS
237 |  |  |  |  |
238 |  |  |  |  | Module use may give one of the following errors during import.
239 |  |  |  |  |
240 |  |  |  |  | =over
241 |  |  |  |  |
242 |  |  |  |  | =item Weak references are not implemented in the version of perl
243 |  |  |  |  |
244 |  |  |  |  | The version of perl that you are using does not implement weak references, to use
245 |  |  |  |  | C<isweak> or C<weaken> you will need to use a newer release of perl.
246 |  |  |  |  |
247 |  |  |  |  | =item Vstrings are not implemented in the version of perl
248 |  |  |  |  |
249 |  |  |  |  | The version of perl that you are using does not implement Vstrings, to use
250 |  |  |  |  | C<isvstring> you will need to use a newer release of perl.
251 |  |  |  |  |
252 |  |  |  |  | =item C<NAME> is only available with the XS version of Scalar::Util
253 |  |  |  |  |
254 |  |  |  |  | C<Scalar::Util> contains both perl and C implementations of many of its functions
255 |  |  |  |  | so that those without access to a C compiler may still use it. However some of the functions
256 |  |  |  |  | are only available when a C compiler was available to compile the XS version of the extension.
257 |  |  |  |  |
258 |  |  |  |  | At present that list is: weaken, isweak, dualvar, isvstring, set_prototype
259 |  |  |  |  |
260 |  |  |  |  | =back
261 |  |  |  |  |
262 |  |  |  |  | =head1 KNOWN BUGS
263 |  |  |  |  |
264 |  |  |  |  | There is a bug in perl5.6.0 with UV's that are >= 1<<31. This will
265 |  |  |  |  | show up as tests 8 and 9 of dualvar.t failing
266 |  |  |  |  |
267 |  |  |  |  | =head1 SEE ALSO
268 |  |  |  |  |
269 |  |  |  |  | L<List::Util>
270 |  |  |  |  |
271 |  |  |  |  | =head1 COPYRIGHT
272 |  |  |  |  |
273 |  |  |  |  | Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
274 |  |  |  |  | This program is free software; you can redistribute it and/or modify it
275 |  |  |  |  | under the same terms as Perl itself.
276 |  |  |  |  |
277 |  |  |  |  | Except weaken and isweak which are
278 |  |  |  |  |
279 |  |  |  |  | Copyright (c) 1999 Tuomas J. Lukka <lukka@iki.fi>. All rights reserved.
280 |  |  |  |  | This program is free software; you can redistribute it and/or modify it
281 |  |  |  |  | under the same terms as perl itself.
282 |  |  |  |  |
283 |  |  |  |  | =cut
|  |  |  |  | # spent 1.32ms within Scalar::Util::blessed which was called 2289 times, avg 576ns/call: # 477 times (313µs+0s) by Class::MOP::Mixin::HasMethods::get_method at line 113 of Class/MOP/Mixin/HasMethods.pm, avg 656ns/call # 477 times (163µs+0s) by Class::MOP::Mixin::HasMethods::get_method at line 115 of Class/MOP/Mixin/HasMethods.pm, avg 342ns/call # 351 times (246µs+0s) by Class::MOP::Mixin::HasMethods::add_method at line 43 of Class/MOP/Mixin/HasMethods.pm, avg 701ns/call # 172 times (130µs+0s) by Class::MOP::Method::Accessor::new at line 26 of Class/MOP/Method/Accessor.pm, avg 756ns/call # 145 times (92µs+0s) by Class::MOP::Method::wrap at line 31 of Class/MOP/Method.pm, avg 636ns/call # 133 times (71µs+0s) by Class::MOP::Object::meta at line 17 of Class/MOP/Object.pm, avg 535ns/call # 119 times (67µs+0s) by Class::MOP::Mixin::HasAttributes::add_attribute at line 21 of Class/MOP/Mixin/HasAttributes.pm, avg 564ns/call # 119 times (61µs+0s) by Class::MOP::Attribute::attach_to_class at line 230 of Class/MOP/Attribute.pm, avg 512ns/call # 43 times (25µs+0s) by Moose::Meta::Role::Application::RoleSummation::meta or Moose::Meta::Role::Application::ToClass::meta or Moose::Meta::Role::Application::ToInstance::meta or Moose::Meta::Role::Application::ToRole::meta or Moose::Meta::Role::Application::meta or Moose::Meta::Role::Composite::meta or Moose::Meta::Role::Method::Required::meta or Moose::Meta::Role::meta or Moose::Meta::TypeCoercion::Union::meta or Moose::Meta::TypeCoercion::meta or Moose::Meta::TypeConstraint::Class::meta or Moose::Meta::TypeConstraint::DuckType::meta or Moose::Meta::TypeConstraint::Enum::meta or Moose::Meta::TypeConstraint::Parameterizable::meta or Moose::Meta::TypeConstraint::Parameterized::meta or Moose::Meta::TypeConstraint::Registry::meta or Moose::Meta::TypeConstraint::Role::meta or Moose::Meta::TypeConstraint::Union::meta or Moose::Meta::TypeConstraint::meta at line 50 of metaclass.pm, avg 579ns/call # 40 times (24µs+0s) by Class::MOP::Mixin::meta at line 14 of Class/MOP/Mixin.pm, avg 607ns/call # 38 times (25µs+0s) by Class::MOP::Instance::BUILDARGS at line 18 of Class/MOP/Instance.pm, avg 661ns/call # 36 times (18µs+0s) by Class::MOP::Method::Wrapped::wrap at line 74 of Class/MOP/Method/Wrapped.pm, avg 506ns/call # 31 times (22µs+0s) by Class::MOP::Method::Constructor::new at line 20 of Class/MOP/Method/Constructor.pm, avg 703ns/call # 23 times (19µs+0s) by Moose::Meta::TypeConstraint::Registry::add_type_constraint at line 47 of Moose/Meta/TypeConstraint/Registry.pm, avg 817ns/call # 23 times (8µs+0s) by Moose::Util::TypeConstraints::find_type_constraint at line 255 of Moose/Util/TypeConstraints.pm, avg 348ns/call # 17 times (10µs+0s) by Moose::Util::TypeConstraints::_create_type_constraint at line 523 of Moose/Util/TypeConstraints.pm, avg 600ns/call # 15 times (8µs+0s) by Class::MOP::class_of at line 60 of Class/MOP.pm, avg 520ns/call # 12 times (6µs+0s) by Class::MOP::Class::clone_object at line 404 of Class/MOP/Class.pm, avg 475ns/call # 12 times (5µs+0s) by Class::MOP::Class::_clone_instance at line 417 of Class/MOP/Class.pm, avg 425ns/call # 4 times (2µs+0s) by Moose::Meta::Class::add_attribute at line 296 of Moose/Meta/Class.pm, avg 600ns/call # once (1µs+0s) by Moose::Meta::Method::Destructor::is_needed at line 58 of Moose/Meta/Method/Destructor.pm # once (800ns+0s) by SimpleDB::Client::new at line 2 of generated method (unknown origin) sub Scalar::Util::blessed; # xsub
|  |  |  |  | # spent 34µs within Scalar::Util::looks_like_number which was called 29 times, avg 1µs/call: # 29 times (34µs+0s) by Class::MOP::Method::Constructor::_generate_slot_initializer at line 151 of Class/MOP/Method/Constructor.pm, avg 1µs/call sub Scalar::Util::looks_like_number; # xsub
|  |  |  |  | # spent 7µs within Scalar::Util::refaddr which was called 2 times, avg 3µs/call: # 2 times (7µs+0s) by Class::MOP::Method::Inlined::can_be_inlined at line 74 of Class/MOP/Method/Inlined.pm, avg 3µs/call sub Scalar::Util::refaddr; # xsub
|  |  |  |  | # spent 128µs within Scalar::Util::reftype which was called 202 times, avg 632ns/call: # 145 times (77µs+0s) by Class::MOP::Method::wrap at line 31 of Class/MOP/Method.pm, avg 532ns/call # 37 times (35µs+0s) by Sub::Install::_CODELIKE at line 98 of Sub/Install.pm, avg 957ns/call # 16 times (11µs+0s) by List::MoreUtils::all at line 302 of Moose/Util/TypeConstraints.pm, avg 681ns/call # 2 times (2µs+0s) by List::MoreUtils::any at line 277 of Moose/Util/TypeConstraints.pm, avg 1µs/call # once (2µs+0s) by Class::MOP::Package::has_package_symbol at line 171 of Class/MOP/Package.pm # once (700ns+0s) by Moose::Util::TypeConstraints::subtype at line 296 of Moose/Util/TypeConstraints.pm sub Scalar::Util::reftype; # xsub
|  |  |  |  | # spent 679µs within Scalar::Util::weaken which was called 718 times, avg 945ns/call: # 304 times (217µs+0s) by Class::MOP::Method::attach_to_class at line 75 of Class/MOP/Method.pm, avg 715ns/call # 172 times (220µs+0s) by Class::MOP::Method::Accessor::new at line 37 of Class/MOP/Method/Accessor.pm, avg 1µs/call # 119 times (113µs+0s) by Class::MOP::Attribute::attach_to_class at line 232 of Class/MOP/Attribute.pm, avg 954ns/call # 52 times (49µs+0s) by Class::MOP::Method::wrap at line 46 of Class/MOP/Method.pm, avg 944ns/call # 38 times (41µs+0s) by Class::MOP::Instance::new at line 42 of Class/MOP/Instance.pm, avg 1µs/call # 31 times (36µs+0s) by Class::MOP::Method::Constructor::new at line 32 of Class/MOP/Method/Constructor.pm, avg 1µs/call # once (900ns+0s) by Moose::Meta::Method::Destructor::new at line 41 of Moose/Meta/Method/Destructor.pm # once (900ns+0s) by Moose::Meta::Method::Constructor::new at line 39 of Moose/Meta/Method/Constructor.pm sub Scalar::Util::weaken; # xsub