Filename | /home/hinrik/perl5/perlbrew/perls/perl-5.13.5/lib/site_perl/5.13.5/Hailo/Engine/Default.pm |
Statements | Executed 25813311 statements in 120s |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
479512 | 1 | 1 | 43.8s | 80.7s | _pos_token | Hailo::Engine::Default::
60000 | 2 | 1 | 10.7s | 103s | _construct_reply | Hailo::Engine::Default::
445416 | 1 | 1 | 5.97s | 10.9s | _token_info | Hailo::Engine::Default::
419579 | 2 | 1 | 5.00s | 11.0s | _expr_id | Hailo::Engine::Default::
30000 | 1 | 1 | 4.59s | 120s | reply | Hailo::Engine::Default::
30000 | 1 | 1 | 569ms | 1.12s | _random_expr | Hailo::Engine::Default::
30000 | 1 | 1 | 147ms | 147ms | _find_rare_tokens | Hailo::Engine::Default::
60001 | 2 | 1 | 100.0ms | 100.0ms | order (xsub) | Hailo::Engine::Default::
60000 | 1 | 1 | 86.7ms | 86.7ms | repeat_limit (xsub) | Hailo::Engine::Default::
60001 | 2 | 1 | 82.5ms | 82.5ms | storage (xsub) | Hailo::Engine::Default::
1 | 1 | 1 | 755µs | 1.77ms | BEGIN@12 | Hailo::Engine::Default::
1 | 1 | 1 | 75µs | 79µs | BUILD | Hailo::Engine::Default::
1 | 1 | 1 | 75µs | 191µs | BEGIN@9 | Hailo::Engine::Default::
1 | 1 | 1 | 32µs | 32µs | BEGIN@2 | Hailo::Engine::Default::
1 | 1 | 1 | 20µs | 111µs | BEGIN@11 | Hailo::Engine::Default::
1 | 1 | 1 | 19µs | 116µs | BEGIN@9.11 | Hailo::Engine::Default::
1 | 1 | 1 | 18µs | 925µs | BEGIN@10 | Hailo::Engine::Default::
1 | 1 | 1 | 17µs | 21µs | __ANON__[:24] | Hailo::Engine::Default::
1 | 1 | 1 | 7µs | 7µs | BEGIN@5 | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | __ANON__[:76] | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _add_expr | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _add_token | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _inc_link | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _token_id | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _token_id_add | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | _token_similar | Hailo::Engine::Default::
0 | 0 | 0 | 0s | 0s | learn | Hailo::Engine::Default::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | package Hailo::Engine::Default; | ||||
2 | # spent 32µs within Hailo::Engine::Default::BEGIN@2 which was called:
# once (32µs+0s) by Hailo::_new_class at line 4 | ||||
3 | 1 | 10µs | $Hailo::Engine::Default::AUTHORITY = 'cpan:AVAR'; | ||
4 | 1 | 38µs | 1 | 32µs | } # spent 32µs making 1 call to Hailo::Engine::Default::BEGIN@2 |
5 | # spent 7µs within Hailo::Engine::Default::BEGIN@5 which was called:
# once (7µs+0s) by Hailo::_new_class at line 7 | ||||
6 | 1 | 8µs | $Hailo::Engine::Default::VERSION = '0.57'; | ||
7 | 1 | 29µs | 1 | 7µs | } # spent 7µs making 1 call to Hailo::Engine::Default::BEGIN@5 |
8 | |||||
9 | 4 | 118µs | 3 | 405µs | use 5.010; # spent 191µs making 1 call to Hailo::Engine::Default::BEGIN@9
# spent 116µs making 1 call to Hailo::Engine::Default::BEGIN@9.11
# spent 98µs making 1 call to feature::import |
10 | 2 | 51µs | 2 | 1.83ms | # spent 925µs (18+906) within Hailo::Engine::Default::BEGIN@10 which was called:
# once (18µs+906µs) by Hailo::_new_class at line 10 # spent 925µs making 1 call to Hailo::Engine::Default::BEGIN@10
# spent 906µs making 1 call to Any::Moose::import |
11 | 2 | 48µs | 2 | 203µs | # spent 111µs (20+92) within Hailo::Engine::Default::BEGIN@11 which was called:
# once (20µs+92µs) by Hailo::_new_class at line 11 # spent 111µs making 1 call to Hailo::Engine::Default::BEGIN@11
# spent 92µs making 1 call to Exporter::import |
12 | 2 | 2.57ms | 2 | 1.99ms | # spent 1.77ms (755µs+1.01) within Hailo::Engine::Default::BEGIN@12 which was called:
# once (755µs+1.01ms) by Hailo::_new_class at line 12 # spent 1.77ms making 1 call to Hailo::Engine::Default::BEGIN@12
# spent 226µs making 1 call to Exporter::import |
13 | |||||
14 | 1 | 6µs | 1 | 10.3ms | with qw[ Hailo::Role::Arguments Hailo::Role::Engine ]; # spent 10.3ms making 1 call to Mouse::with |
15 | |||||
16 | has repeat_limit => ( | ||||
17 | isa => 'Int', | ||||
18 | is => 'rw', | ||||
19 | lazy => 1, | ||||
20 | # spent 21µs (17+4) within Hailo::Engine::Default::__ANON__[/home/hinrik/perl5/perlbrew/perls/perl-5.13.5/lib/site_perl/5.13.5/Hailo/Engine/Default.pm:24] which was called:
# once (17µs+4µs) by Hailo::Engine::Default::repeat_limit at line 287 | ||||
21 | 1 | 2µs | my ($self) = @_; | ||
22 | 1 | 7µs | 1 | 2µs | my $order = $self->order; # spent 2µs making 1 call to Hailo::Engine::Default::order |
23 | 1 | 14µs | 1 | 2µs | return min(($order * 10), 50); # spent 2µs making 1 call to List::Util::min |
24 | } | ||||
25 | 1 | 10µs | 1 | 271µs | ); # spent 271µs making 1 call to Mouse::has |
26 | |||||
27 | # spent 79µs (75+3) within Hailo::Engine::Default::BUILD which was called:
# once (75µs+3µs) by Mouse::Object::new at line 207 of Hailo.pm | ||||
28 | 1 | 1µs | my ($self) = @_; | ||
29 | |||||
30 | # This performance hack is here because in our tight loops calling | ||||
31 | # $self->storage->sth->{...} is actually a significant part of the | ||||
32 | # overall program execution time since we're doing two method | ||||
33 | # calls and hash dereferences for each call to the database. | ||||
34 | |||||
35 | 1 | 13µs | 2 | 3µs | my $sth = $self->storage->sth; # spent 2µs making 1 call to Hailo::Storage::sth
# spent 2µs making 1 call to Hailo::Engine::Default::storage |
36 | 1 | 61µs | while (my ($k, $v) = each %$sth) { | ||
37 | $self->{"_sth_$k"} = $v; | ||||
38 | } | ||||
39 | |||||
40 | 1 | 5µs | return; | ||
41 | } | ||||
42 | |||||
43 | ## no critic (Subroutines::ProhibitExcessComplexity) | ||||
44 | # spent 120s (4.59+115) within Hailo::Engine::Default::reply which was called 30000 times, avg 4.00ms/call:
# 30000 times (4.59s+115s) by Hailo::reply at line 325 of Hailo.pm, avg 4.00ms/call | ||||
45 | 30000 | 35.9ms | my $self = shift; | ||
46 | 30000 | 43.5ms | my $tokens = shift // []; | ||
47 | |||||
48 | # we will favor these tokens when making the reply> shuffle them | ||||
49 | # and discard half. | ||||
50 | 30000 | 74.7ms | my @key_tokens = do { | ||
51 | 30000 | 32.4ms | my $i = 0; | ||
52 | 30000 | 190ms | 30000 | 62.4ms | grep { $i++ % 2 == 0 } shuffle(@$tokens); # spent 62.4ms making 30000 calls to List::Util::shuffle, avg 2µs/call |
53 | }; | ||||
54 | |||||
55 | 30000 | 39.2ms | my (@key_ids, %token_cache); | ||
56 | 30000 | 81.0ms | for my $token_info (@key_tokens) { | ||
57 | my $text = $token_info->[1]; | ||||
58 | my $info = $self->_token_similar($text); | ||||
59 | next unless defined $info; | ||||
60 | my ($id, $spacing) = @$info; | ||||
61 | next unless defined $id; | ||||
62 | push @key_ids, $id; | ||||
63 | next if exists $token_cache{$id}; | ||||
64 | $token_cache{$id} = [$spacing, $text]; | ||||
65 | } | ||||
66 | |||||
67 | # sort the rest by rareness | ||||
68 | 30000 | 140ms | 30000 | 147ms | @key_ids = $self->_find_rare_tokens(\@key_ids, 2); # spent 147ms making 30000 calls to Hailo::Engine::Default::_find_rare_tokens, avg 5µs/call |
69 | |||||
70 | # get the middle expression | ||||
71 | 30000 | 35.7ms | my $seed_token_id = shift @key_ids; | ||
72 | 30000 | 140ms | 30000 | 1.12s | my ($orig_expr_id, @token_ids) = $self->_random_expr($seed_token_id); # spent 1.12s making 30000 calls to Hailo::Engine::Default::_random_expr, avg 37µs/call |
73 | 30000 | 30.7ms | return unless defined $orig_expr_id; # we don't know any expressions yet | ||
74 | |||||
75 | # remove key tokens we're already using | ||||
76 | 30000 | 40.5ms | @key_ids = grep { my $used = $_; !first { $_ == $used } @token_ids } @key_ids; | ||
77 | |||||
78 | 30000 | 31.3ms | my $expr_id = $orig_expr_id; | ||
79 | |||||
80 | # construct the end of the reply | ||||
81 | 30000 | 138ms | 30000 | 48.0s | $self->_construct_reply('next', $expr_id, \@token_ids, \@key_ids); # spent 48.0s making 30000 calls to Hailo::Engine::Default::_construct_reply, avg 1.60ms/call |
82 | |||||
83 | # construct the beginning of the reply | ||||
84 | 30000 | 141ms | 30000 | 55.1s | $self->_construct_reply('prev', $expr_id, \@token_ids, \@key_ids); # spent 55.1s making 30000 calls to Hailo::Engine::Default::_construct_reply, avg 1.84ms/call |
85 | |||||
86 | # translate token ids to token spacing/text | ||||
87 | 479579 | 2.20s | 445416 | 10.9s | my @reply = map { # spent 10.9s making 445416 calls to Hailo::Engine::Default::_token_info, avg 25µs/call |
88 | 30000 | 737ms | $token_cache{$_} // ($token_cache{$_} = $self->_token_info($_)) | ||
89 | } @token_ids; | ||||
90 | 30000 | 236ms | return \@reply; | ||
91 | } | ||||
92 | |||||
93 | # spent 10.9s (5.97+4.95) within Hailo::Engine::Default::_token_info which was called 445416 times, avg 25µs/call:
# 445416 times (5.97s+4.95s) by Hailo::Engine::Default::reply at line 87, avg 25µs/call | ||||
94 | 445416 | 617ms | my ($self, $id) = @_; | ||
95 | |||||
96 | 445416 | 5.05s | 445416 | 3.24s | $self->{_sth_token_info}->execute($id); # spent 3.24s making 445416 calls to DBI::st::execute, avg 7µs/call |
97 | 445416 | 3.86s | 445416 | 1.71s | my @res = $self->{_sth_token_info}->fetchrow_array; # spent 1.71s making 445416 calls to DBI::st::fetchrow_array, avg 4µs/call |
98 | 445416 | 1.64s | return \@res; | ||
99 | } | ||||
100 | |||||
101 | sub learn { | ||||
102 | my ($self, $tokens) = @_; | ||||
103 | my $order = $self->order; | ||||
104 | |||||
105 | # only learn from inputs which are long enough | ||||
106 | return if @$tokens < $order; | ||||
107 | |||||
108 | my %token_cache; | ||||
109 | |||||
110 | for my $token (@$tokens) { | ||||
111 | my $key = join '', @$token; | ||||
112 | next if exists $token_cache{$key}; | ||||
113 | $token_cache{$key} = $self->_token_id_add($token); | ||||
114 | } | ||||
115 | |||||
116 | # process every expression of length $order | ||||
117 | for my $i (0 .. @$tokens - $order) { | ||||
118 | my @expr = map { $token_cache{ join('', @{ $tokens->[$_] }) } } $i .. $i+$order-1; | ||||
119 | my $expr_id = $self->_expr_id(\@expr); | ||||
120 | |||||
121 | if (!defined $expr_id) { | ||||
122 | $expr_id = $self->_add_expr(\@expr); | ||||
123 | $self->{_sth_inc_token_count}->execute($_) for uniq(@expr); | ||||
124 | } | ||||
125 | |||||
126 | # add link to next token for this expression, if any | ||||
127 | if ($i < @$tokens - $order) { | ||||
128 | my $next_id = $token_cache{ join('', @{ $tokens->[$i+$order] }) }; | ||||
129 | $self->_inc_link('next_token', $expr_id, $next_id); | ||||
130 | } | ||||
131 | |||||
132 | # add link to previous token for this expression, if any | ||||
133 | if ($i > 0) { | ||||
134 | my $prev_id = $token_cache{ join('', @{ $tokens->[$i-1] }) }; | ||||
135 | $self->_inc_link('prev_token', $expr_id, $prev_id); | ||||
136 | } | ||||
137 | |||||
138 | # add links to boundary token if appropriate | ||||
139 | my $b = $self->storage->_boundary_token_id; | ||||
140 | $self->_inc_link('prev_token', $expr_id, $b) if $i == 0; | ||||
141 | $self->_inc_link('next_token', $expr_id, $b) if $i == @$tokens-$order; | ||||
142 | } | ||||
143 | |||||
144 | return; | ||||
145 | } | ||||
146 | |||||
147 | # sort token ids based on how rare they are | ||||
148 | # spent 147ms within Hailo::Engine::Default::_find_rare_tokens which was called 30000 times, avg 5µs/call:
# 30000 times (147ms+0s) by Hailo::Engine::Default::reply at line 68, avg 5µs/call | ||||
149 | 30000 | 48.0ms | my ($self, $token_ids, $min) = @_; | ||
150 | 30000 | 127ms | return unless @$token_ids; | ||
151 | |||||
152 | my %links; | ||||
153 | for my $id (@$token_ids) { | ||||
154 | next if exists $links{$id}; | ||||
155 | $self->{_sth_token_count}->execute($id); | ||||
156 | $links{$id} = $self->{_sth_token_count}->fetchrow_array; | ||||
157 | } | ||||
158 | |||||
159 | # remove tokens which are too rare | ||||
160 | my @ids = grep { $links{$_} >= $min } @$token_ids; | ||||
161 | |||||
162 | @ids = sort { $links{$a} <=> $links{$b} } @ids; | ||||
163 | |||||
164 | return @ids; | ||||
165 | } | ||||
166 | |||||
167 | # increase the link weight between an expression and a token | ||||
168 | sub _inc_link { | ||||
169 | my ($self, $type, $expr_id, $token_id) = @_; | ||||
170 | |||||
171 | $self->{"_sth_${type}_count"}->execute($expr_id, $token_id); | ||||
172 | my $count = $self->{"_sth_${type}_count"}->fetchrow_array; | ||||
173 | |||||
174 | if (defined $count) { | ||||
175 | $self->{"_sth_${type}_inc"}->execute($expr_id, $token_id); | ||||
176 | } | ||||
177 | else { | ||||
178 | $self->{"_sth_${type}_add"}->execute($expr_id, $token_id); | ||||
179 | } | ||||
180 | |||||
181 | return; | ||||
182 | } | ||||
183 | |||||
184 | # add new expression to the database | ||||
185 | sub _add_expr { | ||||
186 | my ($self, $token_ids) = @_; | ||||
187 | |||||
188 | # add the expression | ||||
189 | $self->{_sth_add_expr}->execute(@$token_ids); | ||||
190 | return $self->storage->dbh->last_insert_id(undef, undef, "expr", undef); | ||||
191 | } | ||||
192 | |||||
193 | # look up an expression id based on tokens | ||||
194 | # spent 11.0s (5.00+6.01) within Hailo::Engine::Default::_expr_id which was called 419579 times, avg 26µs/call:
# 223787 times (2.66s+3.19s) by Hailo::Engine::Default::_construct_reply at line 308, avg 26µs/call
# 195792 times (2.33s+2.81s) by Hailo::Engine::Default::_construct_reply at line 304, avg 26µs/call | ||||
195 | 419579 | 584ms | my ($self, $tokens) = @_; | ||
196 | 419579 | 6.01s | 419579 | 4.19s | $self->{_sth_expr_id}->execute(@$tokens); # spent 4.19s making 419579 calls to DBI::st::execute, avg 10µs/call |
197 | 419579 | 4.63s | 419579 | 1.81s | return $self->{_sth_expr_id}->fetchrow_array(); # spent 1.81s making 419579 calls to DBI::st::fetchrow_array, avg 4µs/call |
198 | } | ||||
199 | |||||
200 | # return token id if the token exists | ||||
201 | sub _token_id { | ||||
202 | my ($self, $token_info) = @_; | ||||
203 | |||||
204 | $self->{_sth_token_id}->execute(@$token_info); | ||||
205 | my $token_id = $self->{_sth_token_id}->fetchrow_array(); | ||||
206 | |||||
207 | return unless defined $token_id; | ||||
208 | return $token_id; | ||||
209 | } | ||||
210 | |||||
211 | # get token id (adding the token if it doesn't exist) | ||||
212 | sub _token_id_add { | ||||
213 | my ($self, $token_info) = @_; | ||||
214 | |||||
215 | my $token_id = $self->_token_id($token_info); | ||||
216 | $token_id = $self->_add_token($token_info) unless defined $token_id; | ||||
217 | return $token_id; | ||||
218 | } | ||||
219 | |||||
220 | # return all tokens (regardless of spacing) that consist of this text | ||||
221 | sub _token_similar { | ||||
222 | my ($self, $token_text) = @_; | ||||
223 | $self->{_sth_token_similar}->execute($token_text); | ||||
224 | return $self->{_sth_token_similar}->fetchrow_arrayref; | ||||
225 | } | ||||
226 | |||||
227 | # add a new token and return its id | ||||
228 | sub _add_token { | ||||
229 | my ($self, $token_info) = @_; | ||||
230 | $self->{_sth_add_token}->execute(@$token_info); | ||||
231 | return $self->storage->dbh->last_insert_id(undef, undef, "token", undef); | ||||
232 | } | ||||
233 | |||||
234 | # return a random expression containing the given token | ||||
235 | # spent 1.12s (569ms+550ms) within Hailo::Engine::Default::_random_expr which was called 30000 times, avg 37µs/call:
# 30000 times (569ms+550ms) by Hailo::Engine::Default::reply at line 72, avg 37µs/call | ||||
236 | 30000 | 40.7ms | my ($self, $token_id) = @_; | ||
237 | |||||
238 | 30000 | 29.5ms | my $expr; | ||
239 | |||||
240 | 30000 | 72.2ms | if (!defined $token_id) { | ||
241 | 30000 | 553ms | 30000 | 406ms | $self->{_sth_random_expr}->execute(); # spent 406ms making 30000 calls to DBI::st::execute, avg 14µs/call |
242 | 30000 | 290ms | 30000 | 143ms | $expr = $self->{_sth_random_expr}->fetchrow_arrayref(); # spent 143ms making 30000 calls to DBI::st::fetchrow_arrayref, avg 5µs/call |
243 | } | ||||
244 | else { | ||||
245 | # try the positions in a random order | ||||
246 | for my $pos (shuffle 0 .. $self->order-1) { | ||||
247 | my $column = "token${pos}_id"; | ||||
248 | |||||
249 | # get a random expression which includes the token at this position | ||||
250 | $self->{"_sth_expr_by_$column"}->execute($token_id); | ||||
251 | $expr = $self->{"_sth_expr_by_$column"}->fetchrow_arrayref(); | ||||
252 | last if defined $expr; | ||||
253 | } | ||||
254 | } | ||||
255 | |||||
256 | 30000 | 33.1ms | return unless defined $expr; | ||
257 | 30000 | 119ms | return @$expr; | ||
258 | } | ||||
259 | |||||
260 | # return a new next/previous token | ||||
261 | # spent 80.7s (43.8+36.9) within Hailo::Engine::Default::_pos_token which was called 479512 times, avg 168µs/call:
# 479512 times (43.8s+36.9s) by Hailo::Engine::Default::_construct_reply at line 298, avg 168µs/call | ||||
262 | 479512 | 733ms | my ($self, $pos, $expr_id, $key_tokens) = @_; | ||
263 | |||||
264 | 479512 | 7.27s | 479512 | 5.11s | $self->{"_sth_${pos}_token_get"}->execute($expr_id); # spent 5.11s making 479512 calls to DBI::st::execute, avg 11µs/call |
265 | 479512 | 34.1s | 479512 | 31.8s | my $pos_tokens = $self->{"_sth_${pos}_token_get"}->fetchall_arrayref(); # spent 31.8s making 479512 calls to DBI::st::fetchall_arrayref, avg 66µs/call |
266 | |||||
267 | 479512 | 1.07s | if (defined $key_tokens) { | ||
268 | 479512 | 1.46s | for my $i (0 .. $#{ $key_tokens }) { | ||
269 | my $want_id = $key_tokens->[$i]; | ||||
270 | my @ids = map { $_->[0] } @$pos_tokens; | ||||
271 | my $has_id = grep { $_ == $want_id } @ids; | ||||
272 | next unless $has_id; | ||||
273 | return splice @$key_tokens, $i, 1; | ||||
274 | } | ||||
275 | } | ||||
276 | |||||
277 | 479512 | 476ms | my @novel_tokens; | ||
278 | 479512 | 1.11s | for my $token (@$pos_tokens) { | ||
279 | 13916440 | 30.5s | push @novel_tokens, ($token->[0]) x $token->[1]; | ||
280 | } | ||||
281 | 479512 | 4.42s | return $novel_tokens[rand @novel_tokens]; | ||
282 | } | ||||
283 | |||||
284 | sub _construct_reply { | ||||
285 | 60000 | 98.7ms | my ($self, $what, $expr_id, $token_ids, $key_ids) = @_; | ||
286 | 60000 | 336ms | 60000 | 100.0ms | my $order = $self->order; # spent 100.0ms making 60000 calls to Hailo::Engine::Default::order, avg 2µs/call |
287 | 60000 | 300ms | 60003 | 86.7ms | my $repeat_limit = $self->repeat_limit; # spent 86.7ms making 60000 calls to Hailo::Engine::Default::repeat_limit, avg 1µs/call
# spent 21µs making 1 call to Hailo::Engine::Default::__ANON__[Hailo/Engine/Default.pm:24]
# spent 2µs making 1 call to Mouse::Meta::TypeConstraint::_compiled_type_constraint
# spent 2µs making 1 call to Mouse::Meta::Attribute::default |
288 | 60000 | 535ms | 120000 | 171ms | my $boundary_token = $self->storage->_boundary_token_id; # spent 88.5ms making 60000 calls to Hailo::Storage::_boundary_token_id, avg 1µs/call
# spent 82.5ms making 60000 calls to Hailo::Engine::Default::storage, avg 1µs/call |
289 | |||||
290 | 60000 | 61.7ms | my $i = 0; | ||
291 | 60000 | 1.16s | while (1) { | ||
292 | 479579 | 1.05s | 19583 | 276ms | if (($i % $order) == 0 and # spent 276ms making 19583 calls to List::MoreUtils::uniq, avg 14µs/call |
293 | (($i >= $repeat_limit * 3) || | ||||
294 | ($i >= $repeat_limit and uniq(@$token_ids) <= $order))) { | ||||
295 | 67 | 98µs | last; | ||
296 | } | ||||
297 | |||||
298 | 479512 | 1.96s | 479512 | 80.7s | my $id = $self->_pos_token($what, $expr_id, $key_ids); # spent 80.7s making 479512 calls to Hailo::Engine::Default::_pos_token, avg 168µs/call |
299 | 479512 | 636ms | last if $id eq $boundary_token; | ||
300 | |||||
301 | 419579 | 507ms | given ($what) { | ||
302 | 419579 | 631ms | when ('next') { | ||
303 | 195792 | 271ms | push @$token_ids, $id; | ||
304 | 195792 | 1.09s | 195792 | 5.15s | $expr_id = $self->_expr_id([@$token_ids[-$order..-1]]); # spent 5.15s making 195792 calls to Hailo::Engine::Default::_expr_id, avg 26µs/call |
305 | } | ||||
306 | 223787 | 259ms | when ('prev') { | ||
307 | 223787 | 337ms | unshift @$token_ids, $id; | ||
308 | 223787 | 1.28s | 223787 | 5.86s | $expr_id = $self->_expr_id([@$token_ids[0..$order-1]]); # spent 5.86s making 223787 calls to Hailo::Engine::Default::_expr_id, avg 26µs/call |
309 | } | ||||
310 | } | ||||
311 | } continue { | ||||
312 | $i++; | ||||
313 | } | ||||
314 | |||||
315 | 60000 | 233ms | return; | ||
316 | } | ||||
317 | |||||
318 | 1 | 15µs | 2 | 127µs | __PACKAGE__->meta->make_immutable; # spent 114µs making 1 call to Mouse::Meta::Class::make_immutable
# spent 13µs making 1 call to Hailo::Engine::Default::meta |
319 | |||||
320 | =encoding utf8 | ||||
321 | |||||
322 | =head1 NAME | ||||
323 | |||||
324 | Hailo::Engine::Default - The default engine backend for L<Hailo|Hailo> | ||||
325 | |||||
326 | =head1 DESCRIPTION | ||||
327 | |||||
328 | This backend implements the logic of replying to and learning from | ||||
329 | input using the resources given to the L<engine | ||||
330 | roles|Hailo::Role::Engine>. | ||||
331 | |||||
332 | =head1 AUTHORS | ||||
333 | |||||
334 | Hinrik E<Ouml>rn SigurE<eth>sson, hinrik.sig@gmail.com | ||||
335 | |||||
336 | E<AElig>var ArnfjE<ouml>rE<eth> Bjarmason <avar@cpan.org> | ||||
337 | |||||
338 | =head1 LICENSE AND COPYRIGHT | ||||
339 | |||||
340 | Copyright 2010 Hinrik E<Ouml>rn SigurE<eth>sson and | ||||
341 | E<AElig>var ArnfjE<ouml>rE<eth> Bjarmason <avar@cpan.org> | ||||
342 | |||||
343 | This program is free software, you can redistribute it and/or modify | ||||
344 | it under the same terms as Perl itself. | ||||
345 | |||||
346 | =cut | ||||
# spent 100.0ms within Hailo::Engine::Default::order which was called 60001 times, avg 2µs/call:
# 60000 times (100.0ms+0s) by Hailo::Engine::Default::_construct_reply at line 286, avg 2µs/call
# once (2µs+0s) by Hailo::Engine::Default::__ANON__[/home/hinrik/perl5/perlbrew/perls/perl-5.13.5/lib/site_perl/5.13.5/Hailo/Engine/Default.pm:24] at line 22 | |||||
# spent 86.7ms (86.7+24µs) within Hailo::Engine::Default::repeat_limit which was called 60000 times, avg 1µs/call:
# 60000 times (86.7ms+24µs) by Hailo::Engine::Default::_construct_reply at line 287, avg 1µs/call | |||||
sub Hailo::Engine::Default::storage; # xsub |