← Index
NYTProf Performance Profile   « line view »
For rbm/rbm
  Run on Wed Feb 12 03:38:15 2020
Reported on Wed Feb 12 04:56:35 2020

Filename/usr/lib/x86_64-linux-gnu/perl5/5.28/Template/Service.pm
StatementsExecuted 19924392 statements in 37.0s
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
3831611132.0s2134sTemplate::Service::::processTemplate::Service::process (recurses: max depth 40, inclusive time 38558s)
3831611110.5s135sTemplate::Service::::_initTemplate::Service::_init
111804µs1.06msTemplate::Service::::BEGIN@27Template::Service::BEGIN@27
11122µs22µsTemplate::Service::::BEGIN@26Template::Service::BEGIN@26
11117µs21µsTemplate::Service::::BEGIN@23Template::Service::BEGIN@23
11110µs38µsTemplate::Service::::BEGIN@28Template::Service::BEGIN@28
1119µs88µsTemplate::Service::::BEGIN@25Template::Service::BEGIN@25
1118µs40µsTemplate::Service::::BEGIN@24Template::Service::BEGIN@24
1118µs35µsTemplate::Service::::BEGIN@29Template::Service::BEGIN@29
1115µs34µsTemplate::Service::::BEGIN@31Template::Service::BEGIN@31
2212µs2µsTemplate::Service::::__ANON__Template::Service::__ANON__ (xsub)
0000s0sTemplate::Service::::_dumpTemplate::Service::_dump
0000s0sTemplate::Service::::_recoverTemplate::Service::_recover
0000s0sTemplate::Service::::contextTemplate::Service::context
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1#============================================================= -*-Perl-*-
2#
3# Template::Service
4#
5# DESCRIPTION
6# Module implementing a template processing service which wraps a
7# template within PRE_PROCESS and POST_PROCESS templates and offers
8# ERROR recovery.
9#
10# AUTHOR
11# Andy Wardley <abw@wardley.org>
12#
13# COPYRIGHT
14# Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved.
15#
16# This module is free software; you can redistribute it and/or
17# modify it under the same terms as Perl itself.
18#
19#============================================================================
20
21package Template::Service;
22
23225µs224µs
# spent 21µs (17+4) within Template::Service::BEGIN@23 which was called: # once (17µs+4µs) by Template::BEGIN@30 at line 23
use strict;
# spent 21µs making 1 call to Template::Service::BEGIN@23 # spent 4µs making 1 call to strict::import
24225µs271µs
# spent 40µs (8+31) within Template::Service::BEGIN@24 which was called: # once (8µs+31µs) by Template::BEGIN@30 at line 24
use warnings;
# spent 40µs making 1 call to Template::Service::BEGIN@24 # spent 31µs making 1 call to warnings::import
25226µs2168µs
# spent 88µs (9+80) within Template::Service::BEGIN@25 which was called: # once (9µs+80µs) by Template::BEGIN@30 at line 25
use base 'Template::Base';
# spent 88µs making 1 call to Template::Service::BEGIN@25 # spent 80µs making 1 call to base::import
26238µs223µs
# spent 22µs (22+500ns) within Template::Service::BEGIN@26 which was called: # once (22µs+500ns) by Template::BEGIN@30 at line 26
use Template::Config;
# spent 22µs making 1 call to Template::Service::BEGIN@26 # spent 500ns making 1 call to Template::Service::__ANON__
272375µs21.07ms
# spent 1.06ms (804µs+260µs) within Template::Service::BEGIN@27 which was called: # once (804µs+260µs) by Template::BEGIN@30 at line 27
use Template::Exception;
# spent 1.06ms making 1 call to Template::Service::BEGIN@27 # spent 1µs making 1 call to Template::Service::__ANON__
28225µs266µs
# spent 38µs (10+28) within Template::Service::BEGIN@28 which was called: # once (10µs+28µs) by Template::BEGIN@30 at line 28
use Template::Constants;
# spent 38µs making 1 call to Template::Service::BEGIN@28 # spent 28µs making 1 call to Exporter::import
29225µs263µs
# spent 35µs (8+28) within Template::Service::BEGIN@29 which was called: # once (8µs+28µs) by Template::BEGIN@30 at line 29
use Scalar::Util 'blessed';
# spent 35µs making 1 call to Template::Service::BEGIN@29 # spent 28µs making 1 call to Exporter::import
30
3121.00ms262µs
# spent 34µs (5+28) within Template::Service::BEGIN@31 which was called: # once (5µs+28µs) by Template::BEGIN@30 at line 31
use constant EXCEPTION => 'Template::Exception';
# spent 34µs making 1 call to Template::Service::BEGIN@31 # spent 28µs making 1 call to constant::import
32
331300nsour $VERSION = 2.80;
341300nsour $DEBUG = 0 unless defined $DEBUG;
351300nsour $ERROR = '';
36
37
38#========================================================================
39# ----- PUBLIC METHODS -----
40#========================================================================
41
42#------------------------------------------------------------------------
43# process($template, \%params)
44#
45# Process a template within a service framework. A service may encompass
46# PRE_PROCESS and POST_PROCESS templates and an ERROR hash which names
47# templates to be substituted for the main template document in case of
48# error. Each service invocation begins by resetting the state of the
49# context object via a call to reset(). The AUTO_RESET option may be set
50# to 0 (default: 1) to bypass this step.
51#------------------------------------------------------------------------
52
53
# spent 2134s (32.0+2102) within Template::Service::process which was called 383161 times, avg 5.57ms/call: # 383161 times (32.0s+2102s) by Template::process at line 66 of Template.pm, avg 5.57ms/call
sub process {
54383161213ms my ($self, $template, $params) = @_;
55383161362ms my $context = $self->{ CONTEXT };
56383161188ms my ($name, $output, $procout, $error);
57383161340ms $output = '';
58
59 $self->debug("process($template, ",
60 defined $params ? $params : '<no params>',
61383161234ms ')') if $self->{ DEBUG };
62
63 $context->reset()
643831611.35s3831611.71s if $self->{ AUTO_RESET };
# spent 1.71s making 383161 calls to Template::Context::reset, avg 4µs/call
65
66 # pre-request compiled template from context so that we can alias it
67 # in the stash for pre-processed templates to reference
687663221.25s383161414s eval { $template = $context->template($template) };
# spent 414s making 383161 calls to Template::Context::template, avg 1.08ms/call
69383161175ms return $self->error($@)
70 if $@;
71
72 # localise the variable stash with any parameters passed
73 # and set the 'template' variable
74383161225ms $params ||= { };
75 # TODO: change this to C<||=> so we can use a template parameter
76383161904ms $params->{ template } = $template
77 unless ref $template eq 'CODE';
783831611.38s38316112.2s $context->localise($params);
# spent 12.2s making 383161 calls to Template::Context::localise, avg 32µs/call
79
80 SERVICE: {
81 # PRE_PROCESS
82766322431ms eval {
83383161532ms foreach $name (@{ $self->{ PRE_PROCESS } }) {
84 $self->debug("PRE_PROCESS: $name") if $self->{ DEBUG };
85 $output .= $context->process($name);
86 }
87 };
88383161334ms last SERVICE if ($error = $@);
89
90 # PROCESS
91383161173ms eval {
92383161730ms foreach $name (@{ $self->{ PROCESS } || [ $template ] }) {
93383161288ms $self->debug("PROCESS: $name") if $self->{ DEBUG };
943831611.76s3831612133s $procout .= $context->process($name);
# spent 40220s making 383161 calls to Template::Context::process, avg 105ms/call, recursion: max depth 41, sum of overlapping time 38087s
95 }
96 };
97383161247ms if ($error = $@) {
98 last SERVICE
99 unless defined ($procout = $self->_recover(\$error));
100 }
101
102383161281ms if (defined $procout) {
103 # WRAPPER
104383161146ms eval {
105383161604ms foreach $name (reverse @{ $self->{ WRAPPER } }) {
106 $self->debug("WRAPPER: $name") if $self->{ DEBUG };
107 $procout = $context->process($name, { content => $procout });
108 }
109 };
110383161154ms last SERVICE if ($error = $@);
111383161220ms $output .= $procout;
112 }
113
114 # POST_PROCESS
115383161146ms eval {
116383161636ms foreach $name (@{ $self->{ POST_PROCESS } }) {
117 $self->debug("POST_PROCESS: $name") if $self->{ DEBUG };
118 $output .= $context->process($name);
119 }
120 };
121383161109ms last SERVICE if ($error = $@);
122 }
123
124383161742ms3831617.88s $context->delocalise();
# spent 7.88s making 383161 calls to Template::Context::delocalise, avg 21µs/call
125383161381ms delete $params->{ template };
126
127383161199ms if ($error) {
128 # $error = $error->as_string if ref $error;
129 return $self->error($error);
130 }
131
13238316111.8s3831614.18s return $output;
# spent 4.18s making 383161 calls to Template::Document::AUTOLOAD, avg 11µs/call
133}
134
135
136#------------------------------------------------------------------------
137# context()
138#
139# Returns the internal CONTEXT reference.
140#------------------------------------------------------------------------
141
142sub context {
143 return $_[0]->{ CONTEXT };
144}
145
146
147#========================================================================
148# -- PRIVATE METHODS --
149#========================================================================
150
151
# spent 135s (10.5+125) within Template::Service::_init which was called 383161 times, avg 353µs/call: # 383161 times (10.5s+125s) by Template::Base::new at line 65 of Template/Base.pm, avg 353µs/call
sub _init {
152383161248ms my ($self, $config) = @_;
153383161240ms my ($item, $data, $context, $block, $blocks);
154383161359ms my $delim = $config->{ DELIMITER };
155383161442ms $delim = ':' unless defined $delim;
156
157 # coerce PRE_PROCESS, PROCESS and POST_PROCESS to arrays if necessary,
158 # by splitting on non-word characters
159383161943ms foreach $item (qw( PRE_PROCESS PROCESS POST_PROCESS WRAPPER )) {
1601532644620ms $data = $config->{ $item };
16115326442.04s $self->{ $item } = [ ], next unless (defined $data);
162 $data = [ split($delim, $data || '') ]
163 unless ref $data eq 'ARRAY';
164 $self->{ $item } = $data;
165 }
166 # unset PROCESS option unless explicitly specified in config
167 $self->{ PROCESS } = undef
168383161589ms unless defined $config->{ PROCESS };
169
170383161722ms $self->{ ERROR } = $config->{ ERROR } || $config->{ ERRORS };
171 $self->{ AUTO_RESET } = defined $config->{ AUTO_RESET }
172383161518ms ? $config->{ AUTO_RESET } : 1;
173383161471ms $self->{ DEBUG } = ( $config->{ DEBUG } || 0 )
174 & Template::Constants::DEBUG_SERVICE;
175
176 $context = $self->{ CONTEXT } = $config->{ CONTEXT }
1773831611.50s383161125s || Template::Config->context($config)
# spent 125s making 383161 calls to Template::Config::context, avg 326µs/call
178 || return $self->error(Template::Config->error);
179
1803831611.78s return $self;
181}
182
183
184#------------------------------------------------------------------------
185# _recover(\$exception)
186#
187# Examines the internal ERROR hash array to find a handler suitable
188# for the exception object passed by reference. Selecting the handler
189# is done by delegation to the exception's select_handler() method,
190# passing the set of handler keys as arguments. A 'default' handler
191# may also be provided. The handler value represents the name of a
192# template which should be processed.
193#------------------------------------------------------------------------
194
195sub _recover {
196 my ($self, $error) = @_;
197 my $context = $self->{ CONTEXT };
198 my ($hkey, $handler, $output);
199
200 # there shouldn't ever be a non-exception object received at this
201 # point... unless a module like CGI::Carp messes around with the
202 # DIE handler.
203 return undef
204 unless blessed($$error) && $$error->isa(EXCEPTION);
205
206 # a 'stop' exception is thrown by [% STOP %] - we return the output
207 # buffer stored in the exception object
208 return $$error->text()
209 if $$error->type() eq 'stop';
210
211 my $handlers = $self->{ ERROR }
212 || return undef; ## RETURN
213
214 if (ref $handlers eq 'HASH') {
215 if ($hkey = $$error->select_handler(keys %$handlers)) {
216 $handler = $handlers->{ $hkey };
217 $self->debug("using error handler for $hkey") if $self->{ DEBUG };
218 }
219 elsif ($handler = $handlers->{ default }) {
220 # use default handler
221 $self->debug("using default error handler") if $self->{ DEBUG };
222 }
223 else {
224 return undef; ## RETURN
225 }
226 }
227 else {
228 $handler = $handlers;
229 $self->debug("using default error handler") if $self->{ DEBUG };
230 }
231
232 eval { $handler = $context->template($handler) };
233 if ($@) {
234 $$error = $@;
235 return undef; ## RETURN
236 };
237
238 $context->stash->set('error', $$error);
239 eval {
240 $output .= $context->process($handler);
241 };
242 if ($@) {
243 $$error = $@;
244 return undef; ## RETURN
245 }
246
247 return $output;
248}
249
- -
252#------------------------------------------------------------------------
253# _dump()
254#
255# Debug method which return a string representing the internal object
256# state.
257#------------------------------------------------------------------------
258
259sub _dump {
260 my $self = shift;
261 my $context = $self->{ CONTEXT }->_dump();
262 $context =~ s/\n/\n /gm;
263
264 my $error = $self->{ ERROR };
265 $error = join('',
266 "{\n",
267 (map { " $_ => $error->{ $_ }\n" }
268 keys %$error),
269 "}\n")
270 if ref $error;
271
272 local $" = ', ';
273 return <<EOF;
274$self
275PRE_PROCESS => [ @{ $self->{ PRE_PROCESS } } ]
276POST_PROCESS => [ @{ $self->{ POST_PROCESS } } ]
277ERROR => $error
278CONTEXT => $context
279EOF
280}
281
282
28314µs1;
284
285__END__
 
# spent 2µs within Template::Service::__ANON__ which was called 2 times, avg 850ns/call: # once (1µs+0s) by Template::Service::BEGIN@27 at line 27 # once (500ns+0s) by Template::Service::BEGIN@26 at line 26
sub Template::Service::__ANON__; # xsub
Report produced by the NYTProf 6.06 Perl profiler, developed by Tim Bunce based on work by Adam Kaplan and Salvador Fandiño García.