← Index
NYTProf Performance Profile   « block view • line view • sub view »
For ddd2.pl
  Run on Tue May 25 16:52:24 2010
Reported on Tue May 25 16:56:47 2010

File /usr/local/lib/perl5/5.8.8/i686-linux/IO/Handle.pm
Statements Executed 5561
Statement Execution Time 101ms
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
4611150.4ms116msIO::Handle::::autoflushIO::Handle::autoflush
4611221.6ms21.6msIO::Handle::::CORE:syswriteIO::Handle::CORE:syswrite (opcode)
4611121.4ms40.8msIO::Handle::::newIO::Handle::new
13833317.3ms17.3msIO::Handle::::blockingIO::Handle::blocking (xsub)
4611115.6ms37.2msIO::Handle::::syswriteIO::Handle::syswrite
0000s0sIO::Handle::::BEGINIO::Handle::BEGIN
0000s0sIO::Handle::::DESTROYIO::Handle::DESTROY
0000s0sIO::Handle::::_open_mode_stringIO::Handle::_open_mode_string
0000s0sIO::Handle::::closeIO::Handle::close
0000s0sIO::Handle::::constantIO::Handle::constant
0000s0sIO::Handle::::eofIO::Handle::eof
0000s0sIO::Handle::::fcntlIO::Handle::fcntl
0000s0sIO::Handle::::fdopenIO::Handle::fdopen
0000s0sIO::Handle::::filenoIO::Handle::fileno
0000s0sIO::Handle::::format_formfeedIO::Handle::format_formfeed
0000s0sIO::Handle::::format_line_break_charactersIO::Handle::format_line_break_characters
0000s0sIO::Handle::::format_lines_leftIO::Handle::format_lines_left
0000s0sIO::Handle::::format_lines_per_pageIO::Handle::format_lines_per_page
0000s0sIO::Handle::::format_nameIO::Handle::format_name
0000s0sIO::Handle::::format_page_numberIO::Handle::format_page_number
0000s0sIO::Handle::::format_top_nameIO::Handle::format_top_name
0000s0sIO::Handle::::format_writeIO::Handle::format_write
0000s0sIO::Handle::::formlineIO::Handle::formline
0000s0sIO::Handle::::getcIO::Handle::getc
0000s0sIO::Handle::::getlineIO::Handle::getline
0000s0sIO::Handle::::getlinesIO::Handle::getlines
0000s0sIO::Handle::::input_line_numberIO::Handle::input_line_number
0000s0sIO::Handle::::input_record_separatorIO::Handle::input_record_separator
0000s0sIO::Handle::::ioctlIO::Handle::ioctl
0000s0sIO::Handle::::new_from_fdIO::Handle::new_from_fd
0000s0sIO::Handle::::openedIO::Handle::opened
0000s0sIO::Handle::::output_field_separatorIO::Handle::output_field_separator
0000s0sIO::Handle::::output_record_separatorIO::Handle::output_record_separator
0000s0sIO::Handle::::printIO::Handle::print
0000s0sIO::Handle::::printfIO::Handle::printf
0000s0sIO::Handle::::printflushIO::Handle::printflush
0000s0sIO::Handle::::readIO::Handle::read
0000s0sIO::Handle::::statIO::Handle::stat
0000s0sIO::Handle::::sysreadIO::Handle::sysread
0000s0sIO::Handle::::truncateIO::Handle::truncate
0000s0sIO::Handle::::writeIO::Handle::write
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1package IO::Handle;
2
3=head1 NAME
4
5IO::Handle - supply object methods for I/O handles
6
7=head1 SYNOPSIS
8
9 use IO::Handle;
10
11 $io = new IO::Handle;
12 if ($io->fdopen(fileno(STDIN),"r")) {
13 print $io->getline;
14 $io->close;
15 }
16
17 $io = new IO::Handle;
18 if ($io->fdopen(fileno(STDOUT),"w")) {
19 $io->print("Some text\n");
20 }
21
22 # setvbuf is not available by default on Perls 5.8.0 and later.
23 use IO::Handle '_IOLBF';
24 $io->setvbuf($buffer_var, _IOLBF, 1024);
25
26 undef $io; # automatically closes the file if it's open
27
28 autoflush STDOUT 1;
29
30=head1 DESCRIPTION
31
32C<IO::Handle> is the base class for all other IO handle classes. It is
33not intended that objects of C<IO::Handle> would be created directly,
34but instead C<IO::Handle> is inherited from by several other classes
35in the IO hierarchy.
36
37If you are reading this documentation, looking for a replacement for
38the C<FileHandle> package, then I suggest you read the documentation
39for C<IO::File> too.
40
41=head1 CONSTRUCTOR
42
43=over 4
44
45=item new ()
46
47Creates a new C<IO::Handle> object.
48
49=item new_from_fd ( FD, MODE )
50
51Creates an C<IO::Handle> like C<new> does.
52It requires two parameters, which are passed to the method C<fdopen>;
53if the fdopen fails, the object is destroyed. Otherwise, it is returned
54to the caller.
55
56=back
57
58=head1 METHODS
59
60See L<perlfunc> for complete descriptions of each of the following
61supported C<IO::Handle> methods, which are just front ends for the
62corresponding built-in functions:
63
64 $io->close
65 $io->eof
66 $io->fileno
67 $io->format_write( [FORMAT_NAME] )
68 $io->getc
69 $io->read ( BUF, LEN, [OFFSET] )
70 $io->print ( ARGS )
71 $io->printf ( FMT, [ARGS] )
72 $io->stat
73 $io->sysread ( BUF, LEN, [OFFSET] )
74 $io->syswrite ( BUF, [LEN, [OFFSET]] )
75 $io->truncate ( LEN )
76
77See L<perlvar> for complete descriptions of each of the following
78supported C<IO::Handle> methods. All of them return the previous
79value of the attribute and takes an optional single argument that when
80given will set the value. If no argument is given the previous value
81is unchanged (except for $io->autoflush will actually turn ON
82autoflush by default).
83
84 $io->autoflush ( [BOOL] ) $|
85 $io->format_page_number( [NUM] ) $%
86 $io->format_lines_per_page( [NUM] ) $=
87 $io->format_lines_left( [NUM] ) $-
88 $io->format_name( [STR] ) $~
89 $io->format_top_name( [STR] ) $^
90 $io->input_line_number( [NUM]) $.
91
92The following methods are not supported on a per-filehandle basis.
93
94 IO::Handle->format_line_break_characters( [STR] ) $:
95 IO::Handle->format_formfeed( [STR]) $^L
96 IO::Handle->output_field_separator( [STR] ) $,
97 IO::Handle->output_record_separator( [STR] ) $\
98
99 IO::Handle->input_record_separator( [STR] ) $/
100
101Furthermore, for doing normal I/O you might need these:
102
103=over 4
104
105=item $io->fdopen ( FD, MODE )
106
107C<fdopen> is like an ordinary C<open> except that its first parameter
108is not a filename but rather a file handle name, an IO::Handle object,
109or a file descriptor number.
110
111=item $io->opened
112
113Returns true if the object is currently a valid file descriptor, false
114otherwise.
115
116=item $io->getline
117
118This works like <$io> described in L<perlop/"I/O Operators">
119except that it's more readable and can be safely called in a
120list context but still returns just one line. If used as the conditional
121+within a C<while> or C-style C<for> loop, however, you will need to
122+emulate the functionality of <$io> with C<< defined($_ = $io->getline) >>.
123
124=item $io->getlines
125
126This works like <$io> when called in a list context to read all
127the remaining lines in a file, except that it's more readable.
128It will also croak() if accidentally called in a scalar context.
129
130=item $io->ungetc ( ORD )
131
132Pushes a character with the given ordinal value back onto the given
133handle's input stream. Only one character of pushback per handle is
134guaranteed.
135
136=item $io->write ( BUF, LEN [, OFFSET ] )
137
138This C<write> is like C<write> found in C, that is it is the
139opposite of read. The wrapper for the perl C<write> function is
140called C<format_write>.
141
142=item $io->error
143
144Returns a true value if the given handle has experienced any errors
145since it was opened or since the last call to C<clearerr>, or if the
146handle is invalid. It only returns false for a valid handle with no
147outstanding errors.
148
149=item $io->clearerr
150
151Clear the given handle's error indicator. Returns -1 if the handle is
152invalid, 0 otherwise.
153
154=item $io->sync
155
156C<sync> synchronizes a file's in-memory state with that on the
157physical medium. C<sync> does not operate at the perlio api level, but
158operates on the file descriptor (similar to sysread, sysseek and
159systell). This means that any data held at the perlio api level will not
160be synchronized. To synchronize data that is buffered at the perlio api
161level you must use the flush method. C<sync> is not implemented on all
162platforms. Returns "0 but true" on success, C<undef> on error, C<undef>
163for an invalid handle. See L<fsync(3c)>.
164
165=item $io->flush
166
167C<flush> causes perl to flush any buffered data at the perlio api level.
168Any unread data in the buffer will be discarded, and any unwritten data
169will be written to the underlying file descriptor. Returns "0 but true"
170on success, C<undef> on error.
171
172=item $io->printflush ( ARGS )
173
174Turns on autoflush, print ARGS and then restores the autoflush status of the
175C<IO::Handle> object. Returns the return value from print.
176
177=item $io->blocking ( [ BOOL ] )
178
179If called with an argument C<blocking> will turn on non-blocking IO if
180C<BOOL> is false, and turn it off if C<BOOL> is true.
181
182C<blocking> will return the value of the previous setting, or the
183current setting if C<BOOL> is not given.
184
185If an error occurs C<blocking> will return undef and C<$!> will be set.
186
187=back
188
189
190If the C functions setbuf() and/or setvbuf() are available, then
191C<IO::Handle::setbuf> and C<IO::Handle::setvbuf> set the buffering
192policy for an IO::Handle. The calling sequences for the Perl functions
193are the same as their C counterparts--including the constants C<_IOFBF>,
194C<_IOLBF>, and C<_IONBF> for setvbuf()--except that the buffer parameter
195specifies a scalar variable to use as a buffer. You should only
196change the buffer before any I/O, or immediately after calling flush.
197
198WARNING: The IO::Handle::setvbuf() is not available by default on
199Perls 5.8.0 and later because setvbuf() is rather specific to using
200the stdio library, while Perl prefers the new perlio subsystem instead.
201
202WARNING: A variable used as a buffer by C<setbuf> or C<setvbuf> B<must not
203be modified> in any way until the IO::Handle is closed or C<setbuf> or
204C<setvbuf> is called again, or memory corruption may result! Remember that
205the order of global destruction is undefined, so even if your buffer
206variable remains in scope until program termination, it may be undefined
207before the file IO::Handle is closed. Note that you need to import the
208constants C<_IOFBF>, C<_IOLBF>, and C<_IONBF> explicitly. Like C, setbuf
209returns nothing. setvbuf returns "0 but true", on success, C<undef> on
210failure.
211
212Lastly, there is a special method for working under B<-T> and setuid/gid
213scripts:
214
215=over 4
216
217=item $io->untaint
218
219Marks the object as taint-clean, and as such data read from it will also
220be considered taint-clean. Note that this is a very trusting action to
221take, and appropriate consideration for the data source and potential
222vulnerability should be kept in mind. Returns 0 on success, -1 if setting
223the taint-clean flag failed. (eg invalid handle)
224
225=back
226
227=head1 NOTE
228
229An C<IO::Handle> object is a reference to a symbol/GLOB reference (see
230the C<Symbol> package). Some modules that
231inherit from C<IO::Handle> may want to keep object related variables
232in the hash table part of the GLOB. In an attempt to prevent modules
233trampling on each other I propose the that any such module should prefix
234its variables with its own name separated by _'s. For example the IO::Socket
235module keeps a C<timeout> variable in 'io_socket_timeout'.
236
237=head1 SEE ALSO
238
239L<perlfunc>,
240L<perlop/"I/O Operators">,
241L<IO::File>
242
243=head1 BUGS
244
245Due to backwards compatibility, all filehandles resemble objects
246of class C<IO::Handle>, or actually classes derived from that class.
247They actually aren't. Which means you can't derive your own
248class from C<IO::Handle> and inherit those methods.
249
250=head1 HISTORY
251
252Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt>
253
254=cut
255
256359µsuse 5.006_001;
2573120µs127µsuse strict;
# spent 27µs making 1 call to strict::import
25815µsour($VERSION, @EXPORT_OK, @ISA);
259389µs1224µsuse Carp;
# spent 224µs making 1 call to Exporter::import
260385µs1246µsuse Symbol;
# spent 246µs making 1 call to Exporter::import
261358µsuse SelectSaver;
26233.96msuse IO (); # Load the XS module
263
26416µsrequire Exporter;
265112µs@ISA = qw(Exporter);
266
26715µs$VERSION = "1.25";
268163µs$VERSION = eval $VERSION;
269
270118µs@EXPORT_OK = qw(
271 autoflush
272 output_field_separator
273 output_record_separator
274 input_record_separator
275 input_line_number
276 format_page_number
277 format_lines_per_page
278 format_lines_left
279 format_name
280 format_top_name
281 format_line_break_characters
282 format_formfeed
283 format_write
284
285 print
286 printf
287 getline
288 getlines
289
290 printflush
291 flush
292
293 SEEK_SET
294 SEEK_CUR
295 SEEK_END
296 _IOFBF
297 _IOLBF
298 _IONBF
299);
300
301################################################
302## Constructors, destructors.
303##
304
305
# spent 40.8ms (21.4+19.4) within IO::Handle::new which was called 461 times, avg 89µs/call: # 461 times (21.4ms+19.4ms) by IO::Socket::new at line 42 of IO/Socket.pm, avg 89µs/call
sub new {
306184420.4ms my $class = ref($_[0]) || $_[0] || "IO::Handle";
307 @_ == 1 or croak "usage: new $class";
308 my $io = gensym;
# spent 19.4ms making 461 calls to Symbol::gensym, avg 42µs/call
309 bless $io, $class;
310}
311
312sub new_from_fd {
313 my $class = ref($_[0]) || $_[0] || "IO::Handle";
314 @_ == 3 or croak "usage: new_from_fd $class FD, MODE";
315 my $io = gensym;
316 shift;
317 IO::Handle::fdopen($io, @_)
318 or return undef;
319 bless $io, $class;
320}
321
322#
323# There is no need for DESTROY to do anything, because when the
324# last reference to an IO object is gone, Perl automatically
325# closes its associated files (if any). However, to avoid any
326# attempts to autoload DESTROY, we here define it to do nothing.
327#
3289224.41mssub DESTROY {}
329
330
331################################################
332## Open and close.
333##
334
335sub _open_mode_string {
336 my ($mode) = @_;
337 $mode =~ /^\+?(<|>>?)$/
338 or $mode =~ s/^r(\+?)$/$1</
339 or $mode =~ s/^w(\+?)$/$1>/
340 or $mode =~ s/^a(\+?)$/$1>>/
341 or croak "IO::Handle: bad open mode: $mode";
342 $mode;
343}
344
345sub fdopen {
346 @_ == 3 or croak 'usage: $io->fdopen(FD, MODE)';
347 my ($io, $fd, $mode) = @_;
348 local(*GLOB);
349
350 if (ref($fd) && "".$fd =~ /GLOB\(/o) {
351 # It's a glob reference; Alias it as we cannot get name of anon GLOBs
352 my $n = qualify(*GLOB);
353 *GLOB = *{*$fd};
354 $fd = $n;
355 } elsif ($fd =~ m#^\d+$#) {
356 # It's an FD number; prefix with "=".
357 $fd = "=$fd";
358 }
359
360 open($io, _open_mode_string($mode) . '&' . $fd)
361 ? $io : undef;
362}
363
364sub close {
365 @_ == 1 or croak 'usage: $io->close()';
366 my($io) = @_;
367
368 close($io);
369}
370
371################################################
372## Normal I/O functions.
373##
374
375# flock
376# select
377
378sub opened {
379 @_ == 1 or croak 'usage: $io->opened()';
380 defined fileno($_[0]);
381}
382
383sub fileno {
384 @_ == 1 or croak 'usage: $io->fileno()';
385 fileno($_[0]);
386}
387
388sub getc {
389 @_ == 1 or croak 'usage: $io->getc()';
390 getc($_[0]);
391}
392
393sub eof {
394 @_ == 1 or croak 'usage: $io->eof()';
395 eof($_[0]);
396}
397
398sub print {
399 @_ or croak 'usage: $io->print(ARGS)';
400 my $this = shift;
401 print $this @_;
402}
403
404sub printf {
405 @_ >= 2 or croak 'usage: $io->printf(FMT,[ARGS])';
406 my $this = shift;
407 printf $this @_;
408}
409
410sub getline {
411 @_ == 1 or croak 'usage: $io->getline()';
412 my $this = shift;
413 return scalar <$this>;
414}
415
41618µs*gets = \&getline; # deprecated
417
418sub getlines {
419 @_ == 1 or croak 'usage: $io->getlines()';
420 wantarray or
421 croak 'Can\'t call $io->getlines in a scalar context, use $io->getline';
422 my $this = shift;
423 return <$this>;
424}
425
426sub truncate {
427 @_ == 2 or croak 'usage: $io->truncate(LEN)';
428 truncate($_[0], $_[1]);
429}
430
431sub read {
432 @_ == 3 || @_ == 4 or croak 'usage: $io->read(BUF, LEN [, OFFSET])';
433 read($_[0], $_[1], $_[2], $_[3] || 0);
434}
435
436sub sysread {
437 @_ == 3 || @_ == 4 or croak 'usage: $io->sysread(BUF, LEN [, OFFSET])';
438 sysread($_[0], $_[1], $_[2], $_[3] || 0);
439}
440
441sub write {
442 @_ >= 2 && @_ <= 4 or croak 'usage: $io->write(BUF [, LEN [, OFFSET]])';
443 local($\) = "";
444 $_[2] = length($_[1]) unless defined $_[2];
445 print { $_[0] } substr($_[1], $_[3] || 0, $_[2]);
446}
447
448
# spent 37.2ms (15.6+21.6) within IO::Handle::syswrite which was called 461 times, avg 81µs/call: # 461 times (15.6ms+21.6ms) by LWP::Protocol::http::request at line 210 of LWP/Protocol/http.pm, avg 81µs/call
sub syswrite {
44992238.5ms @_ >= 2 && @_ <= 4 or croak 'usage: $io->syswrite(BUF [, LEN [, OFFSET]])';
450 if (defined($_[2])) {
# spent 21.6ms making 461 calls to IO::Handle::CORE:syswrite, avg 47µs/call
451 syswrite($_[0], $_[1], $_[2], $_[3] || 0);
452 } else {
453 syswrite($_[0], $_[1]);
454 }
455}
456
457sub stat {
458 @_ == 1 or croak 'usage: $io->stat()';
459 stat($_[0]);
460}
461
462################################################
463## State modification functions.
464##
465
466
# spent 116ms (50.4+65.8) within IO::Handle::autoflush which was called 461 times, avg 252µs/call: # 461 times (50.4ms+65.8ms) by IO::Socket::new at line 44 of IO/Socket.pm, avg 252µs/call
sub autoflush {
467184432.6ms92263.3ms my $old = new SelectSaver qualify($_[0], caller);
# spent 52.5ms making 461 calls to SelectSaver::new, avg 114µs/call # spent 10.8ms making 461 calls to Symbol::qualify, avg 23µs/call
468 my $prev = $|;
469 $| = @_ > 1 ? $_[1] : 1;
470 $prev;
471}
472
473sub output_field_separator {
474 carp "output_field_separator is not supported on a per-handle basis"
475 if ref($_[0]);
476 my $prev = $,;
477 $, = $_[1] if @_ > 1;
478 $prev;
479}
480
481sub output_record_separator {
482 carp "output_record_separator is not supported on a per-handle basis"
483 if ref($_[0]);
484 my $prev = $\;
485 $\ = $_[1] if @_ > 1;
486 $prev;
487}
488
489sub input_record_separator {
490 carp "input_record_separator is not supported on a per-handle basis"
491 if ref($_[0]);
492 my $prev = $/;
493 $/ = $_[1] if @_ > 1;
494 $prev;
495}
496
497sub input_line_number {
498 local $.;
499 () = tell qualify($_[0], caller) if ref($_[0]);
500 my $prev = $.;
501 $. = $_[1] if @_ > 1;
502 $prev;
503}
504
505sub format_page_number {
506 my $old;
507 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
508 my $prev = $%;
509 $% = $_[1] if @_ > 1;
510 $prev;
511}
512
513sub format_lines_per_page {
514 my $old;
515 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
516 my $prev = $=;
517 $= = $_[1] if @_ > 1;
518 $prev;
519}
520
521sub format_lines_left {
522 my $old;
523 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
524 my $prev = $-;
525 $- = $_[1] if @_ > 1;
526 $prev;
527}
528
529sub format_name {
530 my $old;
531 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
532 my $prev = $~;
533 $~ = qualify($_[1], caller) if @_ > 1;
534 $prev;
535}
536
537sub format_top_name {
538 my $old;
539 $old = new SelectSaver qualify($_[0], caller) if ref($_[0]);
540 my $prev = $^;
541 $^ = qualify($_[1], caller) if @_ > 1;
542 $prev;
543}
544
545sub format_line_break_characters {
546 carp "format_line_break_characters is not supported on a per-handle basis"
547 if ref($_[0]);
548 my $prev = $:;
549 $: = $_[1] if @_ > 1;
550 $prev;
551}
552
553sub format_formfeed {
554 carp "format_formfeed is not supported on a per-handle basis"
555 if ref($_[0]);
556 my $prev = $^L;
557 $^L = $_[1] if @_ > 1;
558 $prev;
559}
560
561sub formline {
562 my $io = shift;
563 my $picture = shift;
564 local($^A) = $^A;
565 local($\) = "";
566 formline($picture, @_);
567 print $io $^A;
568}
569
570sub format_write {
571 @_ < 3 || croak 'usage: $io->write( [FORMAT_NAME] )';
572 if (@_ == 2) {
573 my ($io, $fmt) = @_;
574 my $oldfmt = $io->format_name($fmt);
575 CORE::write($io);
576 $io->format_name($oldfmt);
577 } else {
578 CORE::write($_[0]);
579 }
580}
581
582# XXX undocumented
583sub fcntl {
584 @_ == 3 || croak 'usage: $io->fcntl( OP, VALUE );';
585 my ($io, $op) = @_;
586 return fcntl($io, $op, $_[2]);
587}
588
589# XXX undocumented
590sub ioctl {
591 @_ == 3 || croak 'usage: $io->ioctl( OP, VALUE );';
592 my ($io, $op) = @_;
593 return ioctl($io, $op, $_[2]);
594}
595
596# this sub is for compatability with older releases of IO that used
597# a sub called constant to detemine if a constant existed -- GMB
598#
599# The SEEK_* and _IO?BF constants were the only constants at that time
600# any new code should just chech defined(&CONSTANT_NAME)
601
602sub constant {
6033370µs1122µs no strict 'refs';
# spent 122µs making 1 call to strict::unimport
604 my $name = shift;
605 (($name =~ /^(SEEK_(SET|CUR|END)|_IO[FLN]BF)$/) && defined &{$name})
606 ? &{$name}() : undef;
607}
608
609
610# so that flush.pl can be deprecated
611
612sub printflush {
613 my $io = shift;
614 my $old;
615 $old = new SelectSaver qualify($io, caller) if ref($io);
616 local $| = 1;
617 if(ref($io)) {
618 print $io @_;
619 }
620 else {
621 print @_;
622 }
623}
624
625118µs1;
# spent 21.6ms within IO::Handle::CORE:syswrite which was called 461 times, avg 47µs/call: # 461 times (21.6ms+0s) by IO::Handle::syswrite at line 450 of IO/Handle.pm, avg 47µs/call
sub IO::Handle::CORE:syswrite; # xsub
# spent 17.3ms within IO::Handle::blocking which was called 1383 times, avg 13µs/call: # 461 times (6.02ms+0s) by IO::Socket::connect at line 137 of IO/Socket.pm, avg 13µs/call # 461 times (5.85ms+0s) by IO::Socket::connect at line 113 of IO/Socket.pm, avg 13µs/call # 461 times (5.46ms+0s) by LWP::Protocol::http::_new_socket at line 51 of LWP/Protocol/http.pm, avg 12µs/call
sub IO::Handle::blocking; # xsub
Report produced by the NYTProf 3.11 Perl profiler, developed by Tim Bunce and Adam Kaplan.