1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
|
package IPC::Run3::ProfReporter;
$VERSION = 0.043;
=head1 NAME
IPC::Run3::ProfReporter - base class for handling profiling data
=head1 SYNOPSIS
=head1 DESCRIPTION
See L<IPC::Run3::ProfPP|IPC::Run3::ProfPP> and for an example subclass.
This class just notes and accumulates times; subclasses use methods like
"handle_app_call", "handle_run_exit" and "handle_app_exit" to emit reports on
it. The default methods for these handlers are noops.
If run from the command line, a reporter will be created and run on
each logfile given as a command line parameter or on run3.out if none
are given.
This allows reports to be run like:
perl -MIPC::Run3::ProfPP -e1
perl -MIPC::Run3::ProfPP -e1 foo.out bar.out
Use "-" to read from STDIN (the log file format is meant to be moderately
greppable):
grep "^cvs " run3.out perl -MIPC::Run3::ProfPP -e1 -
Use --app to show only application level statistics (ie don't emit
a report section for each command run).
=cut
use strict;
my $loaded_by;
sub import {
$loaded_by = shift;
}
END {
my @caller;
for ( my $i = 0;; ++$i ) {
my @c = caller $i;
last unless @c;
@caller = @c;
}
if ( $caller[0] eq "main"
&& $caller[1] eq "-e"
) {
require IPC::Run3::ProfLogReader;
require Getopt::Long;
my ( $app, $run );
Getopt::Long::GetOptions(
"app" => \$app,
"run" => \$run,
);
$app = 1, $run = 1 unless $app || $run;
for ( @ARGV ? @ARGV : "" ) {
my $r = IPC::Run3::ProfLogReader->new(
Source => $_,
Handler => $loaded_by->new(
Source => $_,
app_report => $app,
run_report => $run,
),
);
$r->read_all;
}
}
}
=head1 METHODS
=over
=item C<< IPC::Run3::ProfReporter->new >>
Returns a new profile reporting object.
=cut
sub new {
my $class = ref $_[0] ? ref shift : shift;
my $self = bless { @_ }, $class;
$self->{app_report} = 1, $self->{run_report} = 1
unless $self->{app_report} || $self->{run_report};
return $self;
}
=item C<< $reporter->handle_app_call( ... ) >>
=item C<< $reporter->handle_app_exit( ... ) >>
=item C<< $reporter->handle_run_exit( ... ) >>
These methods are called by the handled events (see below).
=cut
sub handle_app_call {}
sub handle_app_exit {}
sub handle_run_exit {}
=item C<< $reporter->app_call(\@cmd, $time) >>
=item C<< $reporter->app_exit($time) >>
=item C<< $reporter->run_exit(@times) >>
$self->app_call( $time );
my $time = $self->get_app_call_time;
Sets the time (in floating point seconds) when the application, run3(),
or system() was called or exited. If no time parameter is passed, uses
IPC::Run3's time routine.
Use get_...() to retrieve these values (and _accum values, too). This
is a separate method to speed the execution time of the setters just a
bit.
=cut
sub app_call {
my $self = shift;
( $self->{app_cmd}, $self->{app_call_time} ) = @_;
$self->handle_app_call if $self->{app_report};
}
sub app_exit {
my $self = shift;
$self->{app_exit_time} = shift;
$self->handle_app_exit if $self->{app_report};
}
sub run_exit {
my $self = shift;
@{$self}{qw(
run_cmd run_call_time sys_call_time sys_exit_time run_exit_time
)} = @_;
++$self->{run_count};
$self->{run_cumulative_time} += $self->get_run_time;
$self->{sys_cumulative_time} += $self->get_sys_time;
$self->handle_run_exit if $self->{run_report};
}
=item C<< $reporter->get_run_count() >>
=item C<< $reporter->get_app_call_time() >>
=item C<< $reporter->get_app_exit_time() >>
=item C<< $reporter->get_app_cmd() >>
=item C<< $reporter->get_app_time() >>
=cut
sub get_run_count { shift->{run_count} }
sub get_app_call_time { shift->{app_call_time} }
sub get_app_exit_time { shift->{app_exit_time} }
sub get_app_cmd { shift->{app_cmd} }
sub get_app_time {
my $self = shift;
$self->get_app_exit_time - $self->get_app_call_time;
}
=item C<< $reporter->get_app_cumulative_time() >>
=cut
sub get_app_cumulative_time {
my $self = shift;
$self->get_app_exit_time - $self->get_app_call_time;
}
=item C<< $reporter->get_run_call_time() >>
=item C<< $reporter->get_run_exit_time() >>
=item C<< $reporter->get_run_time() >>
=cut
sub get_run_call_time { shift->{run_call_time} }
sub get_run_exit_time { shift->{run_exit_time} }
sub get_run_time {
my $self = shift;
$self->get_run_exit_time - $self->get_run_call_time;
}
=item C<< $reporter->get_run_cumulative_time() >>
=cut
sub get_run_cumulative_time { shift->{run_cumulative_time} }
=item C<< $reporter->get_sys_call_time() >>
=item C<< $reporter->get_sys_exit_time() >>
=item C<< $reporter->get_sys_time() >>
=cut
sub get_sys_call_time { shift->{sys_call_time} }
sub get_sys_exit_time { shift->{sys_exit_time} }
sub get_sys_time {
my $self = shift;
$self->get_sys_exit_time - $self->get_sys_call_time;
}
=item C<< $reporter->get_sys_cumulative_time() >>
=cut
sub get_sys_cumulative_time { shift->{sys_cumulative_time} }
=item C<< $reporter->get_run_cmd() >>
=cut
sub get_run_cmd { shift->{run_cmd} }
=back
=head1 LIMITATIONS
=head1 COPYRIGHT
Copyright 2003, R. Barrie Slaymaker, Jr., All Rights Reserved
=head1 LICENSE
You may use this module under the terms of the BSD, Artistic, or GPL licenses,
any version.
=head1 AUTHOR
Barrie Slaymaker <barries@slaysys.com>
=cut
1;
|
