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

Comparing Coro/Coro.pm (file contents):
Revision 1.58 by pcg, Fri Feb 13 23:17:41 2004 UTC vs.
Revision 1.93 by root, Fri Dec 1 19:41:06 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
30 30
31=cut 31=cut
32 32
33package Coro; 33package Coro;
34 34
35BEGIN { eval { require warnings } && warnings->unimport ("uninitialized") } 35use strict;
36no warnings "uninitialized";
36 37
37use Coro::State; 38use Coro::State;
38 39
39use vars qw($idle $main $current); 40use base qw(Coro::State Exporter);
40 41
41use base Exporter; 42our $idle; # idle handler
43our $main; # main coroutine
44our $current; # current coroutine
42 45
43$VERSION = 0.95; 46our $VERSION = '3.0';
44 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 (@_) {
89 95
90$main = new Coro; 96$main = new Coro;
91 97
92=item $current (or as function: current) 98=item $current (or as function: current)
93 99
94The 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.
95 106
96=cut 107=cut
97 108
98# maybe some other module used Coro::Specific before... 109# maybe some other module used Coro::Specific before...
99if ($current) {
100 $main->{specific} = $current->{specific}; 110$main->{specific} = $current->{specific}
101} 111 if $current;
102 112
103$current = $main; 113_set_current $main;
104 114
105sub current() { $current } 115sub current() { $current }
106 116
107=item $idle 117=item $idle
108 118
109The coroutine to switch to when no other coroutine is running. The default 119A callback that is called whenever the scheduler finds no ready coroutines
110implementation 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.
111 122
112=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.
113 126
114# should be done using priorities :( 127Please note that if your callback recursively invokes perl (e.g. for event
115$idle = new Coro sub { 128handlers), then it must be prepared to be called recursively.
129
130=cut
131
132$idle = sub {
116 print STDERR "FATAL: deadlock detected\n"; 133 print STDERR "FATAL: deadlock detected\n";
117 exit(51); 134 exit (51);
118}; 135};
119 136
120# this coroutine is necessary because a coroutine 137# this coroutine is necessary because a coroutine
121# cannot destroy itself. 138# cannot destroy itself.
122my @destroy; 139my @destroy;
123my $manager;
124$manager = new Coro sub { 140my $manager; $manager = new Coro sub {
125 while () { 141 while () {
126 # by overwriting the state object with the manager we destroy it 142 # by overwriting the state object with the manager we destroy it
127 # 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
128 # been readied multiple times. this is harmless since the manager 144 # been readied multiple times. this is harmless since the manager
129 # can be called as many times as neccessary and will always 145 # can be called as many times as neccessary and will always
130 # remove itself from the runqueue 146 # remove itself from the runqueue
131 while (@destroy) { 147 while (@destroy) {
132 my $coro = pop @destroy; 148 my $coro = pop @destroy;
133 $coro->{status} ||= []; 149 $coro->{status} ||= [];
134 $_->ready for @{delete $coro->{join} || []}; 150 $_->ready for @{delete $coro->{join} || []};
135 $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);
136 } 157 }
137 &schedule; 158 &schedule;
138 } 159 }
139}; 160};
140 161
142 163
143=back 164=back
144 165
145=head2 STATIC METHODS 166=head2 STATIC METHODS
146 167
147Static methods are actually functions that operate on the current process only. 168Static methods are actually functions that operate on the current coroutine only.
148 169
149=over 4 170=over 4
150 171
151=item async { ... } [@args...] 172=item async { ... } [@args...]
152 173
153Create a new asynchronous process and return it's process object 174Create a new asynchronous coroutine and return it's coroutine object
154(usually unused). When the sub returns the new process is automatically 175(usually unused). When the sub returns the new coroutine is automatically
155terminated. 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.
156 182
157 # create a new coroutine that just prints its arguments 183 # create a new coroutine that just prints its arguments
158 async { 184 async {
159 print "@_\n"; 185 print "@_\n";
160 } 1,2,3,4; 186 } 1,2,3,4;
161 187
162=cut 188=cut
163 189
164sub async(&@) { 190sub async(&@) {
165 my $pid = new Coro @_; 191 my $pid = new Coro @_;
166 $manager->ready; # this ensures that the stack is cloned from the manager
167 $pid->ready; 192 $pid->ready;
168 $pid; 193 $pid
169} 194}
170 195
171=item schedule 196=item schedule
172 197
173Calls 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
174into the ready queue, so calling this function usually means you will 199into the ready queue, so calling this function usually means you will
175never be called again. 200never be called again unless something else (e.g. an event handler) calls
201ready.
176 202
177=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 }
178 221
179=item cede 222=item cede
180 223
181"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
182ready 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
183current "timeslice" to other coroutines of the same or higher priority. 226current "timeslice" to other coroutines of the same or higher priority.
184 227
185=cut
186
187=item terminate [arg...] 228=item terminate [arg...]
188 229
189Terminates the current process. 230Terminates the current coroutine with the given status values (see L<cancel>).
190
191Future versions of this function will allow result arguments.
192 231
193=cut 232=cut
194 233
195sub terminate { 234sub terminate {
196 $current->{status} = [@_];
197 $current->cancel; 235 $current->cancel (@_);
198 &schedule;
199 die; # NORETURN
200} 236}
201 237
202=back 238=back
203 239
204# dynamic methods 240# dynamic methods
205 241
206=head2 PROCESS METHODS 242=head2 COROUTINE METHODS
207 243
208These are the methods you can call on process objects. 244These are the methods you can call on coroutine objects.
209 245
210=over 4 246=over 4
211 247
212=item new Coro \&sub [, @args...] 248=item new Coro \&sub [, @args...]
213 249
214Create 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
215automatically terminates as if C<terminate> with the returned values were 251automatically terminates as if C<terminate> with the returned values were
216called. To make the process run you must first put it into the ready queue 252called. To make the coroutine run you must first put it into the ready queue
217by calling the ready method. 253by calling the ready method.
218 254
219=cut 255Calling C<exit> in a coroutine will not work correctly, so do not do that.
220 256
257=cut
258
221sub _newcoro { 259sub _new_coro {
222 terminate &{+shift}; 260 terminate &{+shift};
223} 261}
224 262
225sub new { 263sub new {
226 my $class = shift; 264 my $class = shift;
227 bless {
228 _coro_state => (new Coro::State $_[0] && \&_newcoro, @_),
229 }, $class;
230}
231 265
232=item $process->ready 266 $class->SUPER::new (\&_new_coro, @_)
267}
233 268
234Put the given process into the ready queue. 269=item $success = $coroutine->ready
235 270
236=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.
237 274
238=item $process->cancel 275=item $is_ready = $coroutine->is_ready
239 276
240Like 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).
241 283
242=cut 284=cut
243 285
244sub cancel { 286sub cancel {
287 my $self = shift;
288 $self->{status} = [@_];
245 push @destroy, $_[0]; 289 push @destroy, $self;
246 $manager->ready; 290 $manager->ready;
247 &schedule if $current == $_[0]; 291 &schedule if $current == $self;
248} 292}
249 293
250=item $process->join 294=item $coroutine->join
251 295
252Wait until the coroutine terminates and return any values given to the 296Wait until the coroutine terminates and return any values given to the
253C<terminate> function. C<join> can be called multiple times from multiple 297C<terminate> or C<cancel> functions. C<join> can be called multiple times
254processes. 298from multiple coroutine.
255 299
256=cut 300=cut
257 301
258sub join { 302sub join {
259 my $self = shift; 303 my $self = shift;
262 &schedule; 306 &schedule;
263 } 307 }
264 wantarray ? @{$self->{status}} : $self->{status}[0]; 308 wantarray ? @{$self->{status}} : $self->{status}[0];
265} 309}
266 310
267=item $oldprio = $process->prio($newprio) 311=item $oldprio = $coroutine->prio ($newprio)
268 312
269Sets (or gets, if the argument is missing) the priority of the 313Sets (or gets, if the argument is missing) the priority of the
270process. Higher priority processes get run before lower priority 314coroutine. Higher priority coroutines get run before lower priority
271processes. Priorities are small signed integers (currently -4 .. +3), 315coroutines. Priorities are small signed integers (currently -4 .. +3),
272that you can refer to using PRIO_xxx constants (use the import tag :prio 316that you can refer to using PRIO_xxx constants (use the import tag :prio
273to get then): 317to get then):
274 318
275 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
276 3 > 1 > 0 > -1 > -3 > -4 320 3 > 1 > 0 > -1 > -3 > -4
279 current->prio(PRIO_HIGH); 323 current->prio(PRIO_HIGH);
280 324
281The idle coroutine ($Coro::idle) always has a lower priority than any 325The idle coroutine ($Coro::idle) always has a lower priority than any
282existing coroutine. 326existing coroutine.
283 327
284Changing the priority of the current process will take effect immediately, 328Changing the priority of the current coroutine will take effect immediately,
285but changing the priority of processes in the ready queue (but not 329but changing the priority of coroutines in the ready queue (but not
286running) will only take effect after the next schedule (of that 330running) will only take effect after the next schedule (of that
287process). 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.
288 332
289=cut
290
291sub prio {
292 my $old = $_[0]{prio};
293 $_[0]{prio} = $_[1] if @_ > 1;
294 $old;
295}
296
297=item $newprio = $process->nice($change) 333=item $newprio = $coroutine->nice ($change)
298 334
299Similar 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.
300higher values mean lower priority, just as in unix). 336higher values mean lower priority, just as in unix).
301 337
302=cut
303
304sub nice {
305 $_[0]{prio} -= $_[1];
306}
307
308=item $olddesc = $process->desc($newdesc) 338=item $olddesc = $coroutine->desc ($newdesc)
309 339
310Sets (or gets in case the argument is missing) the description for this 340Sets (or gets in case the argument is missing) the description for this
311process. This is just a free-form string you can associate with a process. 341coroutine. This is just a free-form string you can associate with a coroutine.
312 342
313=cut 343=cut
314 344
315sub desc { 345sub desc {
316 my $old = $_[0]{desc}; 346 my $old = $_[0]{desc};
318 $old; 348 $old;
319} 349}
320 350
321=back 351=back
322 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
323=cut 418=cut
324 419
3251; 4201;
326 421
327=head1 BUGS/LIMITATIONS 422=head1 BUGS/LIMITATIONS
334 to allow per-thread schedulers, but Coro::State does not yet allow 429 to allow per-thread schedulers, but Coro::State does not yet allow
335 this). 430 this).
336 431
337=head1 SEE ALSO 432=head1 SEE ALSO
338 433
339L<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>.
340L<Coro::Signal>, L<Coro::State>, L<Coro::Timer>, L<Coro::Event>, 435
341L<Coro::L<Coro::RWLock>, 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>
342 441
343=head1 AUTHOR 442=head1 AUTHOR
344 443
345 Marc Lehmann <pcg@goof.com> 444 Marc Lehmann <schmorp@schmorp.de>
346 http://www.goof.com/pcg/marc/ 445 http://home.schmorp.de/
347 446
348=cut 447=cut
349 448

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines