← Index
NYTProf Performance Profile   « block view • line view • sub view »
For t/app_dpath.t
  Run on Tue Jun 5 15:25:28 2012
Reported on Tue Jun 5 15:26:09 2012

Filename/home/ss5/perl5/perlbrew/perls/perl-5.14.1/lib/site_perl/5.14.1/JSON.pm
StatementsExecuted 105 statements in 16.3ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1117.20ms33.0msJSON::::_load_xs JSON::_load_xs
1113.90ms4.44msJSON::::BEGIN@6 JSON::BEGIN@6
1112.23ms2.23msJSON::::CORE:readline JSON::CORE:readline (opcode)
2211.19ms1.74msJSON::Boolean::::_overrride_overload JSON::Boolean::_overrride_overload
611799µs1.41msJSON::::from_json JSON::from_json
111270µs270µsJSON::::_set_module JSON::_set_module
11160µs491µsJSON::::import JSON::import
11158µs75µsJSON::::BEGIN@4 JSON::BEGIN@4
11157µs129µsJSON::::BEGIN@318 JSON::BEGIN@318
11133µs84µsJSON::Backend::PP::::BEGIN@383JSON::Backend::PP::BEGIN@383
11133µs33µsJSON::::CORE:close JSON::CORE:close (opcode)
11123µs23µsJSON::::BEGIN@9 JSON::BEGIN@9
11114µs14µsJSON::::BEGIN@5 JSON::BEGIN@5
0000s0sJSON::Backend::PP::::__ANON__[:386]JSON::Backend::PP::__ANON__[:386]
0000s0sJSON::Backend::PP::::__ANON__[:387]JSON::Backend::PP::__ANON__[:387]
0000s0sJSON::Backend::PP::::initJSON::Backend::PP::init
0000s0sJSON::::__ANON__[:332] JSON::__ANON__[:332]
0000s0sJSON::::_load_pp JSON::_load_pp
0000s0sJSON::::backend JSON::backend
0000s0sJSON::::false JSON::false
0000s0sJSON::::is_pp JSON::is_pp
0000s0sJSON::::is_xs JSON::is_xs
0000s0sJSON::::jsonToObj JSON::jsonToObj
0000s0sJSON::::null JSON::null
0000s0sJSON::::objToJson JSON::objToJson
0000s0sJSON::::property JSON::property
0000s0sJSON::::pureperl_only_methods JSON::pureperl_only_methods
0000s0sJSON::::require_xs_version JSON::require_xs_version
0000s0sJSON::::to_json JSON::to_json
0000s0sJSON::::true JSON::true
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1package JSON;
2
3
4293µs292µs
# spent 75µs (58+17) within JSON::BEGIN@4 which was called: # once (58µs+17µs) by main::BEGIN@9 at line 4
use strict;
# spent 75µs making 1 call to JSON::BEGIN@4 # spent 17µs making 1 call to strict::import
5296µs114µs
# spent 14µs within JSON::BEGIN@5 which was called: # once (14µs+0s) by main::BEGIN@9 at line 5
use Carp ();
# spent 14µs making 1 call to JSON::BEGIN@5
62555µs24.76ms
# spent 4.44ms (3.90+540µs) within JSON::BEGIN@6 which was called: # once (3.90ms+540µs) by main::BEGIN@9 at line 6
use base qw(Exporter);
# spent 4.44ms making 1 call to JSON::BEGIN@6 # spent 319µs making 1 call to base::import
719µs@JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
8
9
# spent 23µs within JSON::BEGIN@9 which was called: # once (23µs+0s) by main::BEGIN@9 at line 13
BEGIN {
1012µs $JSON::VERSION = '2.53';
1111µs $JSON::DEBUG = 0 unless (defined $JSON::DEBUG);
12117µs $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
1315.72ms123µs}
# spent 23µs making 1 call to JSON::BEGIN@9
14
1512µsmy $Module_XS = 'JSON::XS';
1611µsmy $Module_PP = 'JSON::PP';
1712µsmy $Module_bp = 'JSON::backportPP'; # included in JSON distribution
1811µsmy $PP_Version = '2.27200';
1911µsmy $XS_Version = '2.27';
20
21
22# XS and PP common methods
23
24114µsmy @PublicMethods = qw/
25 ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref
26 allow_blessed convert_blessed filter_json_object filter_json_single_key_object
27 shrink max_depth max_size encode decode decode_prefix allow_unknown
28/;
29
30112µsmy @Properties = qw/
31 ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref
32 allow_blessed convert_blessed shrink max_depth max_size allow_unknown
33/;
34
3511µsmy @XSOnlyMethods = qw//; # Currently nothing
36
3717µsmy @PPOnlyMethods = qw/
38 indent_length sort_by
39 allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed
40/; # JSON::PP specific
41
42
43# used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently)
4411µsmy $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die.
451600nsmy $_INSTALL_ONLY = 2; # Don't call _set_methods()
461600nsmy $_ALLOW_UNSUPPORTED = 0;
471600nsmy $_UNIV_CONV_BLESSED = 0;
481600nsmy $_USSING_bpPP = 0;
49
50
51# Check the environment variable to decide worker module.
52
5313µsunless ($JSON::Backend) {
541900ns $JSON::DEBUG and Carp::carp("Check used worker module...");
55
5613µs my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
57
58113µs133.0ms if ($backend eq '1' or $backend =~ /JSON::XS\s*,\s*JSON::PP/) {
# spent 33.0ms making 1 call to JSON::_load_xs
59 _load_xs($_INSTALL_DONT_DIE) or _load_pp();
60 }
61 elsif ($backend eq '0' or $backend eq 'JSON::PP') {
62 _load_pp();
63 }
64 elsif ($backend eq '2' or $backend eq 'JSON::XS') {
65 _load_xs();
66 }
67 elsif ($backend eq 'JSON::backportPP') {
68 $_USSING_bpPP = 1;
69 _load_pp();
70 }
71 else {
72 Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid.";
73 }
74}
75
76
77
# spent 491µs (60+431) within JSON::import which was called: # once (60µs+431µs) by main::BEGIN@9 at line 9 of t/app_dpath.t
sub import {
7814µs my $pkg = shift;
7911µs my @what_to_export;
801800ns my $no_export;
81
8216µs for my $tag (@_) {
83 if ($tag eq '-support_by_pp') {
84 if (!$_ALLOW_UNSUPPORTED++) {
85 JSON::Backend::XS
86 ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend eq $Module_XS);
87 }
88 next;
89 }
90 elsif ($tag eq '-no_export') {
91 $no_export++, next;
92 }
93 elsif ( $tag eq '-convert_blessed_universally' ) {
94 eval q|
95 require B;
96 *UNIVERSAL::TO_JSON = sub {
97 my $b_obj = B::svref_2object( $_[0] );
98 return $b_obj->isa('B::HV') ? { %{ $_[0] } }
99 : $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
100 : undef
101 ;
102 }
103 | if ( !$_UNIV_CONV_BLESSED++ );
104 next;
105 }
106 push @what_to_export, $tag;
107 }
108
10911µs return if ($no_export);
110
111130µs181µs __PACKAGE__->export_to_level(1, $pkg, @what_to_export);
# spent 81µs making 1 call to Exporter::export_to_level
112}
113
114
115# OBSOLETED
116
117sub jsonToObj {
118 my $alternative = 'from_json';
119 if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
120 shift @_; $alternative = 'decode';
121 }
122 Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead.";
123 return JSON::from_json(@_);
124};
125
126sub objToJson {
127 my $alternative = 'to_json';
128 if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
129 shift @_; $alternative = 'encode';
130 }
131 Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead.";
132 JSON::to_json(@_);
133};
134
135
136# INTERFACES
137
138sub to_json ($@) {
139 if (
140 ref($_[0]) eq 'JSON'
141 or (@_ > 2 and $_[0] eq 'JSON')
142 ) {
143 Carp::croak "to_json should not be called as a method.";
144 }
145 my $json = new JSON;
146
147 if (@_ == 2 and ref $_[1] eq 'HASH') {
148 my $opt = $_[1];
149 for my $method (keys %$opt) {
150 $json->$method( $opt->{$method} );
151 }
152 }
153
154 $json->encode($_[0]);
155}
156
157
158
# spent 1.41ms (799µs+611µs) within JSON::from_json which was called 6 times, avg 235µs/call: # 6 times (799µs+611µs) by main::check at line 28 of t/app_dpath.t, avg 235µs/call
sub from_json ($@) {
159626µs if ( ref($_[0]) eq 'JSON' or $_[0] eq 'JSON' ) {
160 Carp::croak "from_json should not be called as a method.";
161 }
1626528µs6353µs my $json = new JSON;
# spent 353µs making 6 calls to JSON::XS::new, avg 59µs/call
163
164623µs if (@_ == 2 and ref $_[1] eq 'HASH') {
165 my $opt = $_[1];
166 for my $method (keys %$opt) {
167 $json->$method( $opt->{$method} );
168 }
169 }
170
1716733µs6200µs return $json->decode( $_[0] );
# spent 200µs making 6 calls to JSON::XS::decode, avg 33µs/call
172}
173
174
175sub true { $JSON::true }
176
177sub false { $JSON::false }
178
179sub null { undef; }
180
181
182sub require_xs_version { $XS_Version; }
183
184sub backend {
185 my $proto = shift;
186 $JSON::Backend;
187}
188
189#*module = *backend;
190
191
192sub is_xs {
193 return $_[0]->module eq $Module_XS;
194}
195
196
197sub is_pp {
198 return not $_[0]->xs;
199}
200
201
202sub pureperl_only_methods { @PPOnlyMethods; }
203
204
205sub property {
206 my ($self, $name, $value) = @_;
207
208 if (@_ == 1) {
209 my %props;
210 for $name (@Properties) {
211 my $method = 'get_' . $name;
212 if ($name eq 'max_size') {
213 my $value = $self->$method();
214 $props{$name} = $value == 1 ? 0 : $value;
215 next;
216 }
217 $props{$name} = $self->$method();
218 }
219 return \%props;
220 }
221 elsif (@_ > 3) {
222 Carp::croak('property() can take only the option within 2 arguments.');
223 }
224 elsif (@_ == 2) {
225 if ( my $method = $self->can('get_' . $name) ) {
226 if ($name eq 'max_size') {
227 my $value = $self->$method();
228 return $value == 1 ? 0 : $value;
229 }
230 $self->$method();
231 }
232 }
233 else {
234 $self->$name($value);
235 }
236
237}
238
- -
241# INTERNAL
242
243
# spent 33.0ms (7.20+25.8) within JSON::_load_xs which was called: # once (7.20ms+25.8ms) by main::BEGIN@9 at line 58
sub _load_xs {
24412µs my $opt = shift;
245
2461800ns $JSON::DEBUG and Carp::carp "Load $Module_XS.";
247
248 # if called after install module, overload is disable.... why?
24915µs1968µs JSON::Boolean::_overrride_overload($Module_XS);
# spent 968µs making 1 call to JSON::Boolean::_overrride_overload
25017µs1773µs JSON::Boolean::_overrride_overload($Module_PP);
# spent 773µs making 1 call to JSON::Boolean::_overrride_overload
251
2521139µs eval qq|
# spent 778µs executing statements in string eval
# includes 6.65ms spent executing 1 call to 1 sub defined therein.
253 use $Module_XS $XS_Version ();
254 |;
255
25611µs if ($@) {
257 if (defined $opt and $opt & $_INSTALL_DONT_DIE) {
258 $JSON::DEBUG and Carp::carp "Can't load $Module_XS...($@)";
259 return 0;
260 }
261 Carp::croak $@;
262 }
263
26415µs unless (defined $opt and $opt & $_INSTALL_ONLY) {
26519µs1270µs _set_module( $JSON::Backend = $Module_XS );
# spent 270µs making 1 call to JSON::_set_module
26613.06ms12.23ms my $data = join("", <DATA>); # this code is from Jcode 2.xx.
# spent 2.23ms making 1 call to JSON::CORE:readline
267172µs133µs close(DATA);
# spent 33µs making 1 call to JSON::CORE:close
26811.80ms eval $data;
# spent 4.94ms executing statements in string eval
# includes 5.02ms spent executing 7 calls to 21 subs defined therein.
269121µs1102µs JSON::Backend::XS->init;
# spent 102µs making 1 call to JSON::Backend::XS::init
270 }
271
272115µs return 1;
273};
274
275
276sub _load_pp {
277 my $opt = shift;
278 my $backend = $_USSING_bpPP ? $Module_bp : $Module_PP;
279
280 $JSON::DEBUG and Carp::carp "Load $backend.";
281
282 # if called after install module, overload is disable.... why?
283 JSON::Boolean::_overrride_overload($Module_XS);
284 JSON::Boolean::_overrride_overload($backend);
285
286 if ( $_USSING_bpPP ) {
287 eval qq| require $backend |;
288 }
289 else {
290 eval qq| use $backend $PP_Version () |;
291 }
292
293 if ($@) {
294 if ( $backend eq $Module_PP ) {
295 $JSON::DEBUG and Carp::carp "Can't load $Module_PP ($@), so try to load $Module_bp";
296 $_USSING_bpPP++;
297 $backend = $Module_bp;
298 JSON::Boolean::_overrride_overload($backend);
299 local $^W; # if PP installed but invalid version, backportPP redifines methods.
300 eval qq| require $Module_bp |;
301 }
302 Carp::croak $@ if $@;
303 }
304
305 unless (defined $opt and $opt & $_INSTALL_ONLY) {
306 _set_module( $JSON::Backend = $Module_PP ); # even if backportPP, set $Backend with 'JSON::PP'
307 JSON::Backend::PP->init;
308 }
309};
310
311
312
# spent 270µs within JSON::_set_module which was called: # once (270µs+0s) by JSON::_load_xs at line 265
sub _set_module {
31311µs return if defined $JSON::true;
314
31512µs my $module = shift;
316
31719µs local $^W;
31821.17ms2201µs
# spent 129µs (57+72) within JSON::BEGIN@318 which was called: # once (57µs+72µs) by main::BEGIN@9 at line 318
no strict qw(refs);
# spent 129µs making 1 call to JSON::BEGIN@318 # spent 72µs making 1 call to strict::unimport
319
32017µs $JSON::true = ${"$module\::true"};
32114µs $JSON::false = ${"$module\::false"};
322
323134µs push @JSON::ISA, $module;
324138µs push @{"$module\::Boolean::ISA"}, qw(JSON::Boolean);
325
326117µs *{"JSON::is_bool"} = \&{"$module\::is_bool"};
327
32818µs for my $method ($module eq $Module_XS ? @PPOnlyMethods : @XSOnlyMethods) {
329 *{"JSON::$method"} = sub {
330 Carp::carp("$method is not supported in $module.");
331 $_[0];
3328139µs };
333 }
334
335118µs return 1;
336}
337
- -
340#
341# JSON Boolean
342#
343
344package JSON::Boolean;
345
34612µsmy %Installed;
347
348
# spent 1.74ms (1.19+547µs) within JSON::Boolean::_overrride_overload which was called 2 times, avg 871µs/call: # once (605µs+364µs) by JSON::_load_xs at line 249 # once (590µs+183µs) by JSON::_load_xs at line 250
sub _overrride_overload {
349211µs return if ($Installed{ $_[0] }++);
350
35127µs my $boolean = $_[0] . '::Boolean';
352
35321.13ms eval sprintf(q|
# spent 89µs executing statements in string eval
# includes 91µs spent executing 1 call to 3 subs defined therein. # spent 60µs executing statements in string eval
# includes 67µs spent executing 1 call to 3 subs defined therein.
354 package %s;
355 use overload (
356 '""' => sub { ${$_[0]} == 1 ? 'true' : 'false' },
357 'eq' => sub {
358 my ($obj, $op) = ref ($_[0]) ? ($_[0], $_[1]) : ($_[1], $_[0]);
359 if ($op eq 'true' or $op eq 'false') {
360 return "$obj" eq 'true' ? 'true' eq $op : 'false' eq $op;
361 }
362 else {
363 return $obj ? 1 == $op : 0 == $op;
364 }
365 },
366 );
367 |, $boolean);
368
36922µs if ($@) { Carp::croak $@; }
370
371230µs return 1;
372}
373
374
375#
376# Helper classes for Backend Module (PP)
377#
378
379package JSON::Backend::PP;
380
381sub init {
382 local $^W;
3832492µs2135µs
# spent 84µs (33+51) within JSON::Backend::PP::BEGIN@383 which was called: # once (33µs+51µs) by main::BEGIN@9 at line 383
no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called.
# spent 84µs making 1 call to JSON::Backend::PP::BEGIN@383 # spent 51µs making 1 call to strict::unimport
384 *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"};
385 *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"};
386 *{"JSON::PP::is_xs"} = sub { 0 };
387 *{"JSON::PP::is_pp"} = sub { 1 };
388 return 1;
389}
390
391#
392# To save memory, the below lines are read only when XS backend is used.
393#
394
395package JSON;
396
3971121µs1;
398__DATA__
 
# spent 33µs within JSON::CORE:close which was called: # once (33µs+0s) by JSON::_load_xs at line 267
sub JSON::CORE:close; # opcode
# spent 2.23ms within JSON::CORE:readline which was called: # once (2.23ms+0s) by JSON::_load_xs at line 266
sub JSON::CORE:readline; # opcode