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

Diff Legend

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