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

Comparing Coro/Coro.pm (file contents):
Revision 1.40 by root, Sun Oct 28 17:00:05 2001 UTC vs.
Revision 1.102 by root, Fri Dec 29 11:37:49 2006 UTC

8 8
9 async { 9 async {
10 # some asynchronous thread of execution 10 # some asynchronous thread of execution
11 }; 11 };
12 12
13 # alternatively create an async process like this: 13 # alternatively create an async coroutine like this:
14 14
15 sub some_func : Coro { 15 sub some_func : Coro {
16 # some more async code 16 # some more async code
17 } 17 }
18 18
19 cede; 19 cede;
20 20
21=head1 DESCRIPTION 21=head1 DESCRIPTION
22 22
23This module collection manages coroutines. Coroutines are similar to 23This module collection manages coroutines. Coroutines are similar
24Threads but don't run in parallel. 24to threads but don't run in parallel at the same time even on SMP
25machines. The specific flavor of coroutine use din this module also
26guarentees you that it will not switch between coroutines unless
27necessary, at easily-identified points in your program, so locking and
28parallel access are rarely an issue, making coroutine programming much
29safer than threads programming.
25 30
26This module is still experimental, see the BUGS section below. 31(Perl, however, does not natively support real threads but instead does a
32very slow and memory-intensive emulation of processes using threads. This
33is a performance win on Windows machines, and a loss everywhere else).
27 34
28In this module, coroutines are defined as "callchain + lexical variables 35In this module, coroutines are defined as "callchain + lexical variables +
29+ @_ + $_ + $@ + $^W + C stack), that is, a coroutine has it's own 36@_ + $_ + $@ + $/ + C stack), that is, a coroutine has its own callchain,
30callchain, it's own set of lexicals and it's own set of perl's most 37its own set of lexicals and its own set of perls most important global
31important global variables. 38variables.
32 39
33=cut 40=cut
34 41
35package Coro; 42package Coro;
36 43
44use strict;
37no warnings qw(uninitialized); 45no warnings "uninitialized";
38 46
39use Coro::State; 47use Coro::State;
40 48
41use base Exporter; 49use base qw(Coro::State Exporter);
42 50
43$VERSION = 0.51; 51our $idle; # idle handler
52our $main; # main coroutine
53our $current; # current coroutine
44 54
55our $VERSION = '3.3';
56
45@EXPORT = qw(async cede schedule terminate current); 57our @EXPORT = qw(async cede schedule terminate current unblock_sub);
46%EXPORT_TAGS = ( 58our %EXPORT_TAGS = (
47 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)], 59 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
48); 60);
49@EXPORT_OK = @{$EXPORT_TAGS{prio}}; 61our @EXPORT_OK = (@{$EXPORT_TAGS{prio}}, qw(nready));
50 62
51{ 63{
52 my @async; 64 my @async;
53 my $init; 65 my $init;
54 66
55 # this way of handling attributes simply is NOT scalable ;() 67 # this way of handling attributes simply is NOT scalable ;()
56 sub import { 68 sub import {
69 no strict 'refs';
70
57 Coro->export_to_level(1, @_); 71 Coro->export_to_level (1, @_);
72
58 my $old = *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"}{CODE}; 73 my $old = *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"}{CODE};
59 *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"} = sub { 74 *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"} = sub {
60 my ($package, $ref) = (shift, shift); 75 my ($package, $ref) = (shift, shift);
61 my @attrs; 76 my @attrs;
62 for (@_) { 77 for (@_) {
77 }; 92 };
78 } 93 }
79 94
80} 95}
81 96
97=over 4
98
82=item $main 99=item $main
83 100
84This coroutine represents the main program. 101This coroutine represents the main program.
85 102
86=cut 103=cut
87 104
88our $main = new Coro; 105$main = new Coro;
89 106
90=item $current (or as function: current) 107=item $current (or as function: current)
91 108
92The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course). 109The current coroutine (the last coroutine switched to). The initial value
110is C<$main> (of course).
111
112This variable is B<strictly> I<read-only>. It is provided for performance
113reasons. If performance is not essentiel you are encouraged to use the
114C<Coro::current> function instead.
93 115
94=cut 116=cut
95 117
96# maybe some other module used Coro::Specific before... 118# maybe some other module used Coro::Specific before...
97if ($current) {
98 $main->{specific} = $current->{specific}; 119$main->{specific} = $current->{specific}
99} 120 if $current;
100 121
101our $current = $main; 122_set_current $main;
102 123
103sub current() { $current } 124sub current() { $current }
104 125
105=item $idle 126=item $idle
106 127
107The coroutine to switch to when no other coroutine is running. The default 128A callback that is called whenever the scheduler finds no ready coroutines
108implementation prints "FATAL: deadlock detected" and exits. 129to run. The default implementation prints "FATAL: deadlock detected" and
130exits, because the program has no other way to continue.
109 131
110=cut 132This hook is overwritten by modules such as C<Coro::Timer> and
133C<Coro::Event> to wait on an external event that hopefully wake up a
134coroutine so the scheduler can run it.
111 135
112# should be done using priorities :( 136Please note that if your callback recursively invokes perl (e.g. for event
113our $idle = new Coro sub { 137handlers), then it must be prepared to be called recursively.
114 print STDERR "FATAL: deadlock detected\n"; 138
115 exit(51); 139=cut
140
141$idle = sub {
142 require Carp;
143 Carp::croak ("FATAL: deadlock detected");
116}; 144};
117 145
118# this coroutine is necessary because a coroutine 146# this coroutine is necessary because a coroutine
119# cannot destroy itself. 147# cannot destroy itself.
120my @destroy; 148my @destroy;
121my $manager;
122$manager = new Coro sub { 149my $manager; $manager = new Coro sub {
123 while() { 150 while () {
124 # by overwriting the state object with the manager we destroy it 151 # by overwriting the state object with the manager we destroy it
125 # while still being able to schedule this coroutine (in case it has 152 # while still being able to schedule this coroutine (in case it has
126 # been readied multiple times. this is harmless since the manager 153 # been readied multiple times. this is harmless since the manager
127 # can be called as many times as neccessary and will always 154 # can be called as many times as neccessary and will always
128 # remove itself from the runqueue 155 # remove itself from the runqueue
129 while (@destroy) { 156 while (@destroy) {
130 my $coro = pop @destroy; 157 my $coro = pop @destroy;
158
131 $coro->{status} ||= []; 159 $coro->{status} ||= [];
160
132 $_->ready for @{delete $coro->{join} || []}; 161 $_->ready for @{(delete $coro->{join} ) || []};
133 $coro->{_coro_state} = $manager->{_coro_state}; 162 $_->(@{$coro->{status}}) for @{(delete $coro->{destroy_cb}) || []};
163
164 # the next line destroys the coro state, but keeps the
165 # coroutine itself intact (we basically make it a zombie
166 # coroutine that always runs the manager thread, so it's possible
167 # to transfer() to this coroutine).
168 $coro->_clone_state_from ($manager);
134 } 169 }
135 &schedule; 170 &schedule;
136 } 171 }
137}; 172};
138 173
139# static methods. not really. 174# static methods. not really.
140 175
176=back
177
141=head2 STATIC METHODS 178=head2 STATIC METHODS
142 179
143Static methods are actually functions that operate on the current process only. 180Static methods are actually functions that operate on the current coroutine only.
144 181
145=over 4 182=over 4
146 183
147=item async { ... } [@args...] 184=item async { ... } [@args...]
148 185
149Create a new asynchronous process and return it's process object 186Create a new asynchronous coroutine and return it's coroutine object
150(usually unused). When the sub returns the new process is automatically 187(usually unused). When the sub returns the new coroutine is automatically
151terminated. 188terminated.
189
190Calling C<exit> in a coroutine will not work correctly, so do not do that.
191
192When the coroutine dies, the program will exit, just as in the main
193program.
152 194
153 # create a new coroutine that just prints its arguments 195 # create a new coroutine that just prints its arguments
154 async { 196 async {
155 print "@_\n"; 197 print "@_\n";
156 } 1,2,3,4; 198 } 1,2,3,4;
157 199
158The coderef you submit MUST NOT be a closure that refers to variables
159in an outer scope. This does NOT work. Pass arguments into it instead.
160
161=cut 200=cut
162 201
163sub async(&@) { 202sub async(&@) {
164 my $pid = new Coro @_; 203 my $pid = new Coro @_;
165 $manager->ready; # this ensures that the stack is cloned from the manager
166 $pid->ready; 204 $pid->ready;
167 $pid; 205 $pid
168} 206}
169 207
170=item schedule 208=item schedule
171 209
172Calls the scheduler. Please note that the current process will not be put 210Calls the scheduler. Please note that the current coroutine will not be put
173into the ready queue, so calling this function usually means you will 211into the ready queue, so calling this function usually means you will
174never be called again. 212never be called again unless something else (e.g. an event handler) calls
213ready.
175 214
176=cut 215The canonical way to wait on external events is this:
216
217 {
218 # remember current coroutine
219 my $current = $Coro::current;
220
221 # register a hypothetical event handler
222 on_event_invoke sub {
223 # wake up sleeping coroutine
224 $current->ready;
225 undef $current;
226 };
227
228 # call schedule until event occured.
229 # in case we are woken up for other reasons
230 # (current still defined), loop.
231 Coro::schedule while $current;
232 }
177 233
178=item cede 234=item cede
179 235
180"Cede" to other processes. This function puts the current process into the 236"Cede" to other coroutines. This function puts the current coroutine into the
181ready queue and calls C<schedule>, which has the effect of giving up the 237ready queue and calls C<schedule>, which has the effect of giving up the
182current "timeslice" to other coroutines of the same or higher priority. 238current "timeslice" to other coroutines of the same or higher priority.
183 239
184=cut 240=item Coro::cede_notself
241
242Works like cede, but is not exported by default and will cede to any
243coroutine, regardless of priority, once.
185 244
186=item terminate [arg...] 245=item terminate [arg...]
187 246
188Terminates the current process. 247Terminates the current coroutine with the given status values (see L<cancel>).
189
190Future versions of this function will allow result arguments.
191 248
192=cut 249=cut
193 250
194sub terminate { 251sub terminate {
195 $current->{status} = [@_];
196 $current->cancel; 252 $current->cancel (@_);
197 &schedule;
198 die; # NORETURN
199} 253}
200 254
201=back 255=back
202 256
203# dynamic methods 257# dynamic methods
204 258
205=head2 PROCESS METHODS 259=head2 COROUTINE METHODS
206 260
207These are the methods you can call on process objects. 261These are the methods you can call on coroutine objects.
208 262
209=over 4 263=over 4
210 264
211=item new Coro \&sub [, @args...] 265=item new Coro \&sub [, @args...]
212 266
213Create a new process and return it. When the sub returns the process 267Create a new coroutine and return it. When the sub returns the coroutine
214automatically terminates as if C<terminate> with the returned values were 268automatically terminates as if C<terminate> with the returned values were
215called. To start the process you must first put it into the ready queue by 269called. To make the coroutine run you must first put it into the ready queue
216calling the ready method. 270by calling the ready method.
217 271
218The coderef you submit MUST NOT be a closure that refers to variables 272Calling C<exit> in a coroutine will not work correctly, so do not do that.
219in an outer scope. This does NOT work. Pass arguments into it instead.
220 273
221=cut 274=cut
222 275
223sub _newcoro { 276sub _run_coro {
224 terminate &{+shift}; 277 terminate &{+shift};
225} 278}
226 279
227sub new { 280sub new {
228 my $class = shift; 281 my $class = shift;
229 bless {
230 _coro_state => (new Coro::State $_[0] && \&_newcoro, @_),
231 }, $class;
232}
233 282
234=item $process->ready 283 $class->SUPER::new (\&_run_coro, @_)
284}
235 285
236Put the given process into the ready queue. 286=item $success = $coroutine->ready
237 287
238=cut 288Put the given coroutine into the ready queue (according to it's priority)
289and return true. If the coroutine is already in the ready queue, do nothing
290and return false.
239 291
240=item $process->cancel 292=item $is_ready = $coroutine->is_ready
241 293
242Like C<terminate>, but terminates the specified process instead. 294Return wether the coroutine is currently the ready queue or not,
295
296=item $coroutine->cancel (arg...)
297
298Terminates the given coroutine and makes it return the given arguments as
299status (default: the empty list).
243 300
244=cut 301=cut
245 302
246sub cancel { 303sub cancel {
304 my $self = shift;
305 $self->{status} = [@_];
247 push @destroy, $_[0]; 306 push @destroy, $self;
248 $manager->ready; 307 $manager->ready;
249 &schedule if $current == $_[0]; 308 &schedule if $current == $self;
250} 309}
251 310
252=item $process->join 311=item $coroutine->join
253 312
254Wait until the coroutine terminates and return any values given to the 313Wait until the coroutine terminates and return any values given to the
255C<terminate> function. C<join> can be called multiple times from multiple 314C<terminate> or C<cancel> functions. C<join> can be called multiple times
256processes. 315from multiple coroutine.
257 316
258=cut 317=cut
259 318
260sub join { 319sub join {
261 my $self = shift; 320 my $self = shift;
264 &schedule; 323 &schedule;
265 } 324 }
266 wantarray ? @{$self->{status}} : $self->{status}[0]; 325 wantarray ? @{$self->{status}} : $self->{status}[0];
267} 326}
268 327
328=item $coroutine->on_destroy (\&cb)
329
330Registers a callback that is called when this coroutine gets destroyed,
331but before it is joined. The callback gets passed the terminate arguments,
332if any.
333
334=cut
335
336sub on_destroy {
337 my ($self, $cb) = @_;
338
339 push @{ $self->{destroy_cb} }, $cb;
340}
341
269=item $oldprio = $process->prio($newprio) 342=item $oldprio = $coroutine->prio ($newprio)
270 343
271Sets the priority of the process. Higher priority processes get run before 344Sets (or gets, if the argument is missing) the priority of the
272lower priority processes. Priorities are smalled signed integer (currently 345coroutine. Higher priority coroutines get run before lower priority
346coroutines. Priorities are small signed integers (currently -4 .. +3),
273-4 .. +3), that you can refer to using PRIO_xxx constants (use the import 347that you can refer to using PRIO_xxx constants (use the import tag :prio
274tag :prio to get then): 348to get then):
275 349
276 PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN 350 PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN
277 3 > 1 > 0 > -1 > -3 > -4 351 3 > 1 > 0 > -1 > -3 > -4
278 352
279 # set priority to HIGH 353 # set priority to HIGH
280 current->prio(PRIO_HIGH); 354 current->prio(PRIO_HIGH);
281 355
282The idle coroutine ($Coro::idle) always has a lower priority than any 356The idle coroutine ($Coro::idle) always has a lower priority than any
283existing coroutine. 357existing coroutine.
284 358
285Changing the priority of the current process will take effect immediately, 359Changing the priority of the current coroutine will take effect immediately,
286but changing the priority of processes in the ready queue (but not 360but changing the priority of coroutines in the ready queue (but not
287running) will only take effect after the next schedule (of that 361running) will only take effect after the next schedule (of that
288process). This is a bug that will be fixed in some future version. 362coroutine). This is a bug that will be fixed in some future version.
289 363
290=cut
291
292sub prio {
293 my $old = $_[0]{prio};
294 $_[0]{prio} = $_[1] if @_ > 1;
295 $old;
296}
297
298=item $newprio = $process->nice($change) 364=item $newprio = $coroutine->nice ($change)
299 365
300Similar to C<prio>, but subtract the given value from the priority (i.e. 366Similar to C<prio>, but subtract the given value from the priority (i.e.
301higher values mean lower priority, just as in unix). 367higher values mean lower priority, just as in unix).
302 368
303=cut 369=item $olddesc = $coroutine->desc ($newdesc)
304 370
305sub nice { 371Sets (or gets in case the argument is missing) the description for this
306 $_[0]{prio} -= $_[1]; 372coroutine. This is just a free-form string you can associate with a coroutine.
373
374=cut
375
376sub desc {
377 my $old = $_[0]{desc};
378 $_[0]{desc} = $_[1] if @_ > 1;
379 $old;
307} 380}
308 381
309=back 382=back
310 383
384=head2 GLOBAL FUNCTIONS
385
386=over 4
387
388=item Coro::nready
389
390Returns the number of coroutines that are currently in the ready state,
391i.e. that can be swicthed to. The value C<0> means that the only runnable
392coroutine is the currently running one, so C<cede> would have no effect,
393and C<schedule> would cause a deadlock unless there is an idle handler
394that wakes up some coroutines.
395
396=item unblock_sub { ... }
397
398This utility function takes a BLOCK or code reference and "unblocks" it,
399returning the new coderef. This means that the new coderef will return
400immediately without blocking, returning nothing, while the original code
401ref will be called (with parameters) from within its own coroutine.
402
403The reason this fucntion exists is that many event libraries (such as the
404venerable L<Event|Event> module) are not coroutine-safe (a weaker form
405of thread-safety). This means you must not block within event callbacks,
406otherwise you might suffer from crashes or worse.
407
408This function allows your callbacks to block by executing them in another
409coroutine where it is safe to block. One example where blocking is handy
410is when you use the L<Coro::AIO|Coro::AIO> functions to save results to
411disk.
412
413In short: simply use C<unblock_sub { ... }> instead of C<sub { ... }> when
414creating event callbacks that want to block.
415
416=cut
417
418our @unblock_pool;
419our @unblock_queue;
420our $UNBLOCK_POOL_SIZE = 2;
421
422sub unblock_handler_ {
423 while () {
424 my ($cb, @arg) = @{ delete $Coro::current->{arg} };
425 $cb->(@arg);
426
427 last if @unblock_pool >= $UNBLOCK_POOL_SIZE;
428 push @unblock_pool, $Coro::current;
429 schedule;
430 }
431}
432
433our $unblock_scheduler = async {
434 while () {
435 while (my $cb = pop @unblock_queue) {
436 my $handler = (pop @unblock_pool or new Coro \&unblock_handler_);
437 $handler->{arg} = $cb;
438 $handler->ready;
439 cede;
440 }
441
442 schedule;
443 }
444};
445
446sub unblock_sub(&) {
447 my $cb = shift;
448
449 sub {
450 push @unblock_queue, [$cb, @_];
451 $unblock_scheduler->ready;
452 }
453}
454
455=back
456
311=cut 457=cut
312 458
3131; 4591;
314 460
315=head1 BUGS/LIMITATIONS 461=head1 BUGS/LIMITATIONS
316 462
317 - you must make very sure that no coro is still active on global destruction. 463 - you must make very sure that no coro is still active on global
318 very bad things might happen otherwise (usually segfaults). 464 destruction. very bad things might happen otherwise (usually segfaults).
465
319 - this module is not thread-safe. You must only ever use this module from 466 - this module is not thread-safe. You should only ever use this module
320 the same thread (this requirement might be loosened in the future to 467 from the same thread (this requirement might be losened in the future
321 allow per-thread schedulers, but Coro::State does not yet allow this). 468 to allow per-thread schedulers, but Coro::State does not yet allow
469 this).
322 470
323=head1 SEE ALSO 471=head1 SEE ALSO
324 472
325L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>, 473Support/Utility: L<Coro::Cont>, L<Coro::Specific>, L<Coro::State>, L<Coro::Util>.
326L<Coro::Signal>, L<Coro::State>, L<Coro::Event>, L<Coro::RWLock>, 474
327L<Coro::Handle>, L<Coro::Socket>. 475Locking/IPC: L<Coro::Signal>, L<Coro::Channel>, L<Coro::Semaphore>, L<Coro::SemaphoreSet>, L<Coro::RWLock>.
476
477Event/IO: L<Coro::Timer>, L<Coro::Event>, L<Coro::Handle>, L<Coro::Socket>, L<Coro::Select>.
478
479Embedding: L<Coro:MakeMaker>
328 480
329=head1 AUTHOR 481=head1 AUTHOR
330 482
331 Marc Lehmann <pcg@goof.com> 483 Marc Lehmann <schmorp@schmorp.de>
332 http://www.goof.com/pcg/marc/ 484 http://home.schmorp.de/
333 485
334=cut 486=cut
335 487

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines