Profile of IO/File.pm

← Index
NYTProf Performance Profile «line view»
For t/bug-md-11.t
Run on Fri Mar 8 13:27:24 2024
Reported on Fri Mar 8 13:30:23 2024

Filename | /home/micha/.plenv/versions/5.38.2/lib/perl5/site_perl/5.38.2/x86_64-linux/IO/File.pm
Statements | Executed 130 statements in 808µs

Subroutines
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
1 | 1 | 1 | 587µs | 682µs | IO::File::::BEGIN@122IO::File::BEGIN@122
1 | 1 | 1 | 236µs | 2.24ms | IO::File::::BEGIN@124IO::File::BEGIN@124
1 | 1 | 1 | 161µs | 210µs | IO::File::::BEGIN@123IO::File::BEGIN@123
9 | 2 | 2 | 64µs | 274µs | IO::File::::openIO::File::open
9 | 2 | 2 | 35µs | 133µs | IO::File::::newIO::File::new
1 | 1 | 1 | 11µs | 11µs | IO::File::::BEGIN@119IO::File::BEGIN@119
1 | 1 | 1 | 4µs | 6µs | IO::File::::BEGIN@120IO::File::BEGIN@120
1 | 1 | 1 | 4µs | 25µs | IO::File::::BEGIN@121IO::File::BEGIN@121
1 | 1 | 1 | 600ns | 600ns | IO::File::::__ANON__IO::File::__ANON__ (xsub)

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

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  | #
2 |  |  |  |  |
3 |  |  |  |  | package IO::File;
4 |  |  |  |  |
5 |  |  |  |  | =head1 NAME
6 |  |  |  |  |
7 |  |  |  |  | IO::File - supply object methods for filehandles
8 |  |  |  |  |
9 |  |  |  |  | =head1 SYNOPSIS
10 |  |  |  |  |
11 |  |  |  |  | use IO::File;
12 |  |  |  |  |
13 |  |  |  |  | my $fh = IO::File->new();
14 |  |  |  |  | if ($fh->open("< file")) {
15 |  |  |  |  | print <$fh>;
16 |  |  |  |  | $fh->close;
17 |  |  |  |  | }
18 |  |  |  |  |
19 |  |  |  |  | my $fh = IO::File->new("> file");
20 |  |  |  |  | if (defined $fh) {
21 |  |  |  |  | print $fh "bar\n";
22 |  |  |  |  | $fh->close;
23 |  |  |  |  | }
24 |  |  |  |  |
25 |  |  |  |  | my $fh = IO::File->new("file", "r");
26 |  |  |  |  | if (defined $fh) {
27 |  |  |  |  | print <$fh>;
28 |  |  |  |  | undef $fh; # automatically closes the file
29 |  |  |  |  | }
30 |  |  |  |  |
31 |  |  |  |  | my $fh = IO::File->new("file", O_WRONLY|O_APPEND);
32 |  |  |  |  | if (defined $fh) {
33 |  |  |  |  | print $fh "corge\n";
34 |  |  |  |  |
35 |  |  |  |  | my $pos = $fh->getpos;
36 |  |  |  |  | $fh->setpos($pos);
37 |  |  |  |  |
38 |  |  |  |  | undef $fh; # automatically closes the file
39 |  |  |  |  | }
40 |  |  |  |  |
41 |  |  |  |  | autoflush STDOUT 1;
42 |  |  |  |  |
43 |  |  |  |  | =head1 DESCRIPTION
44 |  |  |  |  |
45 |  |  |  |  | C<IO::File> inherits from C<IO::Handle> and C<IO::Seekable>. It extends
46 |  |  |  |  | these classes with methods that are specific to file handles.
47 |  |  |  |  |
48 |  |  |  |  | =head1 CONSTRUCTOR
49 |  |  |  |  |
50 |  |  |  |  | =over 4
51 |  |  |  |  |
52 |  |  |  |  | =item new ( FILENAME [,MODE [,PERMS]] )
53 |  |  |  |  |
54 |  |  |  |  | Creates an C<IO::File>. If it receives any parameters, they are passed to
55 |  |  |  |  | the method C<open>; if the open fails, the object is destroyed. Otherwise,
56 |  |  |  |  | it is returned to the caller.
57 |  |  |  |  |
58 |  |  |  |  | =item new_tmpfile
59 |  |  |  |  |
60 |  |  |  |  | Creates an C<IO::File> opened for read/write on a newly created temporary
61 |  |  |  |  | file. On systems where this is possible, the temporary file is anonymous
62 |  |  |  |  | (i.e. it is unlinked after creation, but held open). If the temporary
63 |  |  |  |  | file cannot be created or opened, the C<IO::File> object is destroyed.
64 |  |  |  |  | Otherwise, it is returned to the caller.
65 |  |  |  |  |
66 |  |  |  |  | =back
67 |  |  |  |  |
68 |  |  |  |  | =head1 METHODS
69 |  |  |  |  |
70 |  |  |  |  | =over 4
71 |  |  |  |  |
72 |  |  |  |  | =item open( FILENAME [,MODE [,PERMS]] )
73 |  |  |  |  |
74 |  |  |  |  | =item open( FILENAME, IOLAYERS )
75 |  |  |  |  |
76 |  |  |  |  | C<open> accepts one, two or three parameters. With one parameter,
77 |  |  |  |  | it is just a front end for the built-in C<open> function. With two or three
78 |  |  |  |  | parameters, the first parameter is a filename that may include
79 |  |  |  |  | whitespace or other special characters, and the second parameter is
80 |  |  |  |  | the open mode, optionally followed by a file permission value.
81 |  |  |  |  |
82 |  |  |  |  | If C<IO::File::open> receives a Perl mode string ("E<gt>", "+E<lt>", etc.)
83 |  |  |  |  | or an ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic
84 |  |  |  |  | Perl C<open> operator (but protects any special characters).
85 |  |  |  |  |
86 |  |  |  |  | If C<IO::File::open> is given a numeric mode, it passes that mode
87 |  |  |  |  | and the optional permissions value to the Perl C<sysopen> operator.
88 |  |  |  |  | The permissions default to 0666.
89 |  |  |  |  |
90 |  |  |  |  | If C<IO::File::open> is given a mode that includes the C<:> character,
91 |  |  |  |  | it passes all the three arguments to the three-argument C<open> operator.
92 |  |  |  |  |
93 |  |  |  |  | For convenience, C<IO::File> exports the O_XXX constants from the
94 |  |  |  |  | Fcntl module, if this module is available.
95 |  |  |  |  |
96 |  |  |  |  | =back
97 |  |  |  |  |
98 |  |  |  |  | =head1 NOTE
99 |  |  |  |  |
100 |  |  |  |  | Some operating systems may perform C<IO::File::new()> or C<IO::File::open()>
101 |  |  |  |  | on a directory without errors. This behavior is not portable and not
102 |  |  |  |  | suggested for use. Using C<opendir()> and C<readdir()> or C<IO::Dir> are
103 |  |  |  |  | suggested instead.
104 |  |  |  |  |
105 |  |  |  |  | =head1 SEE ALSO
106 |  |  |  |  |
107 |  |  |  |  | L<perlfunc>,
108 |  |  |  |  | L<perlop/"I/O Operators">,
109 |  |  |  |  | L<IO::Handle>,
110 |  |  |  |  | L<IO::Seekable>,
111 |  |  |  |  | L<IO::Dir>
112 |  |  |  |  |
113 |  |  |  |  | =head1 HISTORY
114 |  |  |  |  |
115 |  |  |  |  | Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt>.
116 |  |  |  |  |
117 |  |  |  |  | =cut
118 |  |  |  |  |
119 | 2 | 29µs | 1 | 11µs | # spent 11µs within IO::File::BEGIN@119 which was called: # once (11µs+0s) by Archive::Zip::BEGIN@7 at line 119 use 5.008_001; # spent 11µs making 1 call to IO::File::BEGIN@119
120 | 2 | 15µs | 2 | 8µs | # spent 6µs (4+2) within IO::File::BEGIN@120 which was called: # once (4µs+2µs) by Archive::Zip::BEGIN@7 at line 120 use strict; # spent 6µs making 1 call to IO::File::BEGIN@120 # spent 2µs making 1 call to strict::import
121 | 2 | 14µs | 2 | 46µs | # spent 25µs (4+21) within IO::File::BEGIN@121 which was called: # once (4µs+21µs) by Archive::Zip::BEGIN@7 at line 121 use Carp; # spent 25µs making 1 call to IO::File::BEGIN@121 # spent 21µs making 1 call to Exporter::import
122 | 2 | 73µs | 2 | 705µs | # spent 682µs (587+95) within IO::File::BEGIN@122 which was called: # once (587µs+95µs) by Archive::Zip::BEGIN@7 at line 122 use Symbol; # spent 682µs making 1 call to IO::File::BEGIN@122 # spent 23µs making 1 call to Exporter::import
123 | 2 | 94µs | 2 | 210µs | # spent 210µs (161+48) within IO::File::BEGIN@123 which was called: # once (161µs+48µs) by Archive::Zip::BEGIN@7 at line 123 use SelectSaver; # spent 210µs making 1 call to IO::File::BEGIN@123 # spent 600ns making 1 call to IO::File::__ANON__
124 | 2 | 278µs | 2 | 2.26ms | # spent 2.24ms (236µs+2.00) within IO::File::BEGIN@124 which was called: # once (236µs+2.00ms) by Archive::Zip::BEGIN@7 at line 124 use IO::Seekable; # spent 2.24ms making 1 call to IO::File::BEGIN@124 # spent 18µs making 1 call to Exporter::import
125 |  |  |  |  |
126 | 1 | 400ns |  |  | require Exporter;
127 |  |  |  |  |
128 | 1 | 8µs |  |  | our @ISA = qw(IO::Handle IO::Seekable Exporter);
129 |  |  |  |  |
130 | 1 | 200ns |  |  | our $VERSION = "1.55";
131 |  |  |  |  |
132 | 1 | 600ns |  |  | our @EXPORT = @IO::Seekable::EXPORT;
133 |  |  |  |  |
134 | 1 | 300ns |  |  | eval {
135 |  |  |  |  | # Make all Fcntl O_XXX constants available for importing
136 | 1 | 300ns |  |  | require Fcntl;
137 | 1 | 55µs | 68 | 10µs | my @O = grep /^O_/, @Fcntl::EXPORT; # spent 10µs making 68 calls to CORE::match, avg 140ns/call
138 | 1 | 2µs | 1 | 69µs | Fcntl->import(@O); # first we import what we want to export # spent 69µs making 1 call to Exporter::import
139 | 1 | 6µs |  |  | push(@EXPORT, @O);
140 |  |  |  |  | };
141 |  |  |  |  |
142 |  |  |  |  | ################################################
143 |  |  |  |  | ## Constructor
144 |  |  |  |  | ##
145 |  |  |  |  |
146 |  |  |  |  | # spent 133µs (35+98) within IO::File::new which was called 9 times, avg 15µs/call: # 8 times (24µs+46µs) by Archive::Zip::_newFileHandle at line 491 of Archive/Zip.pm, avg 9µs/call # once (11µs+52µs) by Spreadsheet::ParseXLSX::_check_signature at line 122 of /home/micha/Projekt/spreadsheet-parsexlsx/lib/Spreadsheet/ParseXLSX.pm sub new {
147 | 9 | 1µs |  |  | my $type = shift;
148 | 9 | 3µs |  |  | my $class = ref($type) || $type || "IO::File";
149 | 9 | 5µs |  |  | @_ >= 0 && @_ <= 3
150 |  |  |  |  | or croak "usage: $class->new([FILENAME [,MODE [,PERMS]]])";
151 | 9 | 11µs | 9 | 56µs | my $fh = $class->SUPER::new(); # spent 56µs making 9 calls to IO::Handle::new, avg 6µs/call
152 | 9 | 3µs | 1 | 42µs | if (@_) { # spent 42µs making 1 call to IO::File::open
153 |  |  |  |  | $fh->open(@_)
154 |  |  |  |  | or return undef;
155 |  |  |  |  | }
156 | 9 | 10µs |  |  | $fh;
157 |  |  |  |  | }
158 |  |  |  |  |
159 |  |  |  |  | ################################################
160 |  |  |  |  | ## Open
161 |  |  |  |  | ##
162 |  |  |  |  |
163 |  |  |  |  | # spent 274µs (64+210) within IO::File::open which was called 9 times, avg 30µs/call: # 8 times (52µs+180µs) by Archive::Zip::_newFileHandle at line 492 of Archive/Zip.pm, avg 29µs/call # once (12µs+30µs) by IO::File::new at line 152 sub open {
164 | 9 | 3µs |  |  | @_ >= 2 && @_ <= 4 or croak 'usage: $fh->open(FILENAME [,MODE [,PERMS]])';
165 | 9 | 3µs |  |  | my ($fh, $file) = @_;
166 | 9 | 3µs |  |  | if (@_ > 2) {
167 | 9 | 5µs |  |  | my ($mode, $perms) = @_[2, 3];
168 | 9 | 24µs | 18 | 9µs | if ($mode =~ /^\d+$/) { # spent 9µs making 18 calls to CORE::match, avg 489ns/call
169 |  |  |  |  | defined $perms or $perms = 0666;
170 |  |  |  |  | return sysopen($fh, $file, $mode, $perms);
171 |  |  |  |  | } elsif ($mode =~ /:/) {
172 |  |  |  |  | return open($fh, $mode, $file) if @_ == 3;
173 |  |  |  |  | croak 'usage: $fh->open(FILENAME, IOLAYERS)';
174 |  |  |  |  | } else {
175 | 9 | 156µs | 18 | 201µs | return open($fh, IO::Handle::_open_mode_string($mode), $file); # spent 118µs making 9 calls to CORE::open, avg 13µs/call # spent 83µs making 9 calls to IO::Handle::_open_mode_string, avg 9µs/call
176 |  |  |  |  | }
177 |  |  |  |  | }
178 |  |  |  |  | open($fh, $file);
179 |  |  |  |  | }
180 |  |  |  |  |
181 | 1 | 5µs |  |  | 1;
|  |  |  |  | # spent 600ns within IO::File::__ANON__ which was called: # once (600ns+0s) by IO::File::BEGIN@123 at line 123 sub IO::File::__ANON__; # xsub