| 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 | Hailo::Engine::Default::_pos_token |
| 60000 | 2 | 1 | 10.7s | 103s | Hailo::Engine::Default::_construct_reply |
| 445416 | 1 | 1 | 5.97s | 10.9s | Hailo::Engine::Default::_token_info |
| 419579 | 2 | 1 | 5.00s | 11.0s | Hailo::Engine::Default::_expr_id |
| 30000 | 1 | 1 | 4.59s | 120s | Hailo::Engine::Default::reply |
| 30000 | 1 | 1 | 569ms | 1.12s | Hailo::Engine::Default::_random_expr |
| 30000 | 1 | 1 | 147ms | 147ms | Hailo::Engine::Default::_find_rare_tokens |
| 60001 | 2 | 1 | 100.0ms | 100.0ms | Hailo::Engine::Default::order (xsub) |
| 60000 | 1 | 1 | 86.7ms | 86.7ms | Hailo::Engine::Default::repeat_limit (xsub) |
| 60001 | 2 | 1 | 82.5ms | 82.5ms | Hailo::Engine::Default::storage (xsub) |
| 1 | 1 | 1 | 755µs | 1.77ms | Hailo::Engine::Default::BEGIN@12 |
| 1 | 1 | 1 | 75µs | 79µs | Hailo::Engine::Default::BUILD |
| 1 | 1 | 1 | 75µs | 191µs | Hailo::Engine::Default::BEGIN@9 |
| 1 | 1 | 1 | 32µs | 32µs | Hailo::Engine::Default::BEGIN@2 |
| 1 | 1 | 1 | 20µs | 111µs | Hailo::Engine::Default::BEGIN@11 |
| 1 | 1 | 1 | 19µs | 116µs | Hailo::Engine::Default::BEGIN@9.11 |
| 1 | 1 | 1 | 18µs | 925µs | Hailo::Engine::Default::BEGIN@10 |
| 1 | 1 | 1 | 17µs | 21µs | Hailo::Engine::Default::__ANON__[:24] |
| 1 | 1 | 1 | 7µs | 7µs | Hailo::Engine::Default::BEGIN@5 |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::__ANON__[:76] |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_add_expr |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_add_token |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_inc_link |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_token_id |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_token_id_add |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::_token_similar |
| 0 | 0 | 0 | 0s | 0s | Hailo::Engine::Default::learn |
| 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 | 3 | 23µs | my ($self) = @_; | ||
| 22 | 1 | 2µs | my $order = $self->order; # spent 2µs making 1 call to Hailo::Engine::Default::order | ||
| 23 | 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 | 4 | 80µ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 | 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 | while (my ($k, $v) = each %$sth) { | ||||
| 37 | $self->{"_sth_$k"} = $v; | ||||
| 38 | } | ||||
| 39 | |||||
| 40 | 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 | 450000 | 1.94s | my $self = shift; | ||
| 46 | my $tokens = shift // []; | ||||
| 47 | |||||
| 48 | # we will favor these tokens when making the reply> shuffle them | ||||
| 49 | # and discard half. | ||||
| 50 | 60000 | 222ms | my @key_tokens = do { | ||
| 51 | my $i = 0; | ||||
| 52 | 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 | my (@key_ids, %token_cache); | ||||
| 56 | 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 | 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 | my $seed_token_id = shift @key_ids; | ||||
| 72 | 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 | return unless defined $orig_expr_id; # we don't know any expressions yet | ||||
| 74 | |||||
| 75 | # remove key tokens we're already using | ||||
| 76 | @key_ids = grep { my $used = $_; !first { $_ == $used } @token_ids } @key_ids; | ||||
| 77 | |||||
| 78 | my $expr_id = $orig_expr_id; | ||||
| 79 | |||||
| 80 | # construct the end of the reply | ||||
| 81 | 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 | 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 | 445416 | 10.9s | my @reply = map { # spent 10.9s making 445416 calls to Hailo::Engine::Default::_token_info, avg 25µs/call | ||
| 88 | 479579 | 2.20s | $token_cache{$_} // ($token_cache{$_} = $self->_token_info($_)) | ||
| 89 | } @token_ids; | ||||
| 90 | 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 | 1781664 | 11.2s | my ($self, $id) = @_; | ||
| 95 | |||||
| 96 | 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 | 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 | 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 | 60000 | 175ms | my ($self, $token_ids, $min) = @_; | ||
| 150 | 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 | 1258737 | 11.2s | my ($self, $tokens) = @_; | ||
| 196 | 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 | 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 | 150000 | 295ms | my ($self, $token_id) = @_; | ||
| 237 | |||||
| 238 | my $expr; | ||||
| 239 | |||||
| 240 | 60000 | 843ms | if (!defined $token_id) { | ||
| 241 | 30000 | 406ms | $self->{_sth_random_expr}->execute(); # spent 406ms making 30000 calls to DBI::st::execute, avg 14µs/call | ||
| 242 | 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 | return unless defined $expr; | ||||
| 257 | 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 | 3356584 | 49.2s | my ($self, $pos, $expr_id, $key_tokens) = @_; | ||
| 263 | |||||
| 264 | 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 | 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.46s | if (defined $key_tokens) { | ||
| 268 | 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 | my @novel_tokens; | ||||
| 278 | for my $token (@$pos_tokens) { | ||||
| 279 | 13916440 | 30.5s | push @novel_tokens, ($token->[0]) x $token->[1]; | ||
| 280 | } | ||||
| 281 | return $novel_tokens[rand @novel_tokens]; | ||||
| 282 | } | ||||
| 283 | |||||
| 284 | sub _construct_reply { | ||||
| 285 | 420000 | 2.73s | my ($self, $what, $expr_id, $token_ids, $key_ids) = @_; | ||
| 286 | 60000 | 100.0ms | my $order = $self->order; # spent 100.0ms making 60000 calls to Hailo::Engine::Default::order, avg 2µs/call | ||
| 287 | 1 | 13µs | 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 | 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 | my $i = 0; | ||||
| 291 | 1858182 | 4.15s | while (1) { | ||
| 292 | 67 | 98µs | 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 | last; | ||||
| 296 | } | ||||
| 297 | |||||
| 298 | 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 | last if $id eq $boundary_token; | ||||
| 300 | |||||
| 301 | 643366 | 891ms | given ($what) { | ||
| 302 | 391584 | 1.36s | when ('next') { | ||
| 303 | push @$token_ids, $id; | ||||
| 304 | 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 | 447574 | 1.61s | when ('prev') { | ||
| 307 | unshift @$token_ids, $id; | ||||
| 308 | 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 | 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 |