ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/Coro/Coro.pm
(Generate patch)

Comparing Coro/Coro.pm (file contents):
Revision 1.130 by root, Thu Sep 20 12:02:25 2007 UTC vs.
Revision 1.137 by root, Wed Sep 26 19:26:48 2007 UTC

… …
113reasons. If performance is not essential you are encouraged to use the 113reasons. If performance is not essential you are encouraged to use the
114C<Coro::current> function instead. 114C<Coro::current> function instead.
115 115
116=cut 116=cut
117 117
118$main->{desc} = "[main::]";
119
118# maybe some other module used Coro::Specific before... 120# maybe some other module used Coro::Specific before...
119$main->{specific} = $current->{specific} 121$main->{specific} = $current->{specific}
120 if $current; 122 if $current;
121 123
122_set_current $main; 124_set_current $main;
… …
153 # call all destruction callbacks 155 # call all destruction callbacks
154 $_->(@{$self->{status}}) 156 $_->(@{$self->{status}})
155 for @{(delete $self->{destroy_cb}) || []}; 157 for @{(delete $self->{destroy_cb}) || []};
156} 158}
157 159
160sub _do_trace {
161 $current->{_trace_cb}->();
162}
163
158# this coroutine is necessary because a coroutine 164# this coroutine is necessary because a coroutine
159# cannot destroy itself. 165# cannot destroy itself.
160my @destroy; 166my @destroy;
161my $manager; 167my $manager;
162 168
163$manager = new Coro sub { 169$manager = new Coro sub {
164 $current->desc ("[coro manager]");
165
166 while () { 170 while () {
167 (shift @destroy)->_cancel 171 (shift @destroy)->_cancel
168 while @destroy; 172 while @destroy;
169 173
170 &schedule; 174 &schedule;
171 } 175 }
172}; 176};
173 177$manager->desc ("[coro manager]");
174$manager->prio (PRIO_MAX); 178$manager->prio (PRIO_MAX);
175 179
176# static methods. not really. 180# static methods. not really.
177 181
178=back 182=back
… …
224The pool size is limited to 8 idle coroutines (this can be adjusted by 228The pool size is limited to 8 idle coroutines (this can be adjusted by
225changing $Coro::POOL_SIZE), and there can be as many non-idle coros as 229changing $Coro::POOL_SIZE), and there can be as many non-idle coros as
226required. 230required.
227 231
228If you are concerned about pooled coroutines growing a lot because a 232If you are concerned about pooled coroutines growing a lot because a
229single C<async_pool> used a lot of stackspace you can e.g. C<async_pool { 233single C<async_pool> used a lot of stackspace you can e.g. C<async_pool
230terminate }> once per second or so to slowly replenish the pool. 234{ terminate }> once per second or so to slowly replenish the pool. In
235addition to that, when the stacks used by a handler grows larger than 16kb
236(adjustable with $Coro::POOL_RSS) it will also exit.
231 237
232=cut 238=cut
233 239
234our $POOL_SIZE = 8; 240our $POOL_SIZE = 8;
235our $MAX_POOL_RSS = 64 * 1024; 241our $POOL_RSS = 16 * 1024;
236our @pool; 242our @async_pool;
237 243
238sub pool_handler { 244sub pool_handler {
245 my $cb;
246
239 while () { 247 while () {
240 $current->{desc} = "[async_pool]";
241
242 eval { 248 eval {
243 my ($cb, @arg) = @{ delete $current->{_invoke} or return }; 249 while () {
244 $cb->(@arg); 250 _pool_1 $cb;
251 &$cb;
252 _pool_2 $cb;
253 &schedule;
254 }
245 }; 255 };
256
257 last if $@ eq "\3terminate\2\n";
246 warn $@ if $@; 258 warn $@ if $@;
247
248 last if @pool >= $POOL_SIZE || $current->rss >= $MAX_POOL_RSS;
249
250 push @pool, $current;
251 $current->{desc} = "[async_pool idle]";
252 $current->save (Coro::State::SAVE_DEF);
253 $current->prio (0);
254 schedule;
255 } 259 }
256} 260}
257 261
258sub async_pool(&@) { 262sub async_pool(&@) {
259 # this is also inlined into the unlock_scheduler 263 # this is also inlined into the unlock_scheduler
260 my $coro = (pop @pool) || new Coro \&pool_handler;; 264 my $coro = (pop @async_pool) || new Coro \&pool_handler;
261 265
262 $coro->{_invoke} = [@_]; 266 $coro->{_invoke} = [@_];
263 $coro->ready; 267 $coro->ready;
264 268
265 $coro 269 $coro
… …
531 535
532# we create a special coro because we want to cede, 536# we create a special coro because we want to cede,
533# to reduce pressure on the coro pool (because most callbacks 537# to reduce pressure on the coro pool (because most callbacks
534# return immediately and can be reused) and because we cannot cede 538# return immediately and can be reused) and because we cannot cede
535# inside an event callback. 539# inside an event callback.
536our $unblock_scheduler = async { 540our $unblock_scheduler = new Coro sub {
537 $current->desc ("[unblock_sub scheduler]");
538 while () { 541 while () {
539 while (my $cb = pop @unblock_queue) { 542 while (my $cb = pop @unblock_queue) {
540 # this is an inlined copy of async_pool 543 # this is an inlined copy of async_pool
541 my $coro = (pop @pool or new Coro \&pool_handler); 544 my $coro = (pop @async_pool) || new Coro \&pool_handler;
542 545
543 $coro->{_invoke} = $cb; 546 $coro->{_invoke} = $cb;
544 $coro->ready; 547 $coro->ready;
545 cede; # for short-lived callbacks, this reduces pressure on the coro pool 548 cede; # for short-lived callbacks, this reduces pressure on the coro pool
546 } 549 }
547 schedule; # sleep well 550 schedule; # sleep well
548 } 551 }
549}; 552};
553$unblock_scheduler->desc ("[unblock_sub scheduler]");
550 554
551sub unblock_sub(&) { 555sub unblock_sub(&) {
552 my $cb = shift; 556 my $cb = shift;
553 557
554 sub { 558 sub {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines