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

Comparing Coro/Coro.pm (file contents):
Revision 1.181 by root, Fri May 9 22:04:37 2008 UTC vs.
Revision 1.201 by root, Mon Sep 29 12:40:50 2008 UTC

… …
16 cede; # yield to coroutine 16 cede; # yield to coroutine
17 print "3\n"; 17 print "3\n";
18 cede; # and again 18 cede; # and again
19 19
20 # use locking 20 # use locking
21 use Coro::Semaphore;
21 my $lock = new Coro::Semaphore; 22 my $lock = new Coro::Semaphore;
22 my $locked; 23 my $locked;
23 24
24 $lock->down; 25 $lock->down;
25 $locked = 1; 26 $locked = 1;
… …
35parallel access are rarely an issue, making coroutine programming much 36parallel access are rarely an issue, making coroutine programming much
36safer and easier than threads programming. 37safer and easier than threads programming.
37 38
38Unlike a normal perl program, however, coroutines allow you to have 39Unlike a normal perl program, however, coroutines allow you to have
39multiple running interpreters that share data, which is especially useful 40multiple running interpreters that share data, which is especially useful
40to code pseudo-parallel processes, such as multiple HTTP-GET requests 41to code pseudo-parallel processes and for event-based programming, such as
41running concurrently. 42multiple HTTP-GET requests running concurrently. See L<Coro::AnyEvent> to
43learn more.
42 44
43Coroutines are also useful because Perl has no support for threads (the so 45Coroutines are also useful because Perl has no support for threads (the so
44called "threads" that perl offers are nothing more than the (bad) process 46called "threads" that perl offers are nothing more than the (bad) process
45emulation coming from the Windows platform: On standard operating systems 47emulation coming from the Windows platform: On standard operating systems
46they serve no purpose whatsoever, except by making your programs slow and 48they serve no purpose whatsoever, except by making your programs slow and
… …
65 67
66our $idle; # idle handler 68our $idle; # idle handler
67our $main; # main coroutine 69our $main; # main coroutine
68our $current; # current coroutine 70our $current; # current coroutine
69 71
70our $VERSION = 4.6; 72our $VERSION = 4.749;
71 73
72our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub); 74our @EXPORT = qw(async async_pool cede schedule terminate current unblock_sub);
73our %EXPORT_TAGS = ( 75our %EXPORT_TAGS = (
74 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)], 76 prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
75); 77);
… …
80=item $Coro::main 82=item $Coro::main
81 83
82This variable stores the coroutine object that represents the main 84This variable stores the coroutine object that represents the main
83program. While you cna C<ready> it and do most other things you can do to 85program. While you cna C<ready> it and do most other things you can do to
84coroutines, it is mainly useful to compare again C<$Coro::current>, to see 86coroutines, it is mainly useful to compare again C<$Coro::current>, to see
85wether you are running in the main program or not. 87whether you are running in the main program or not.
86 88
87=cut 89=cut
88 90
89$main = new Coro; 91$main = new Coro;
90 92
… …
265 _pool_2 $cb; 267 _pool_2 $cb;
266 &schedule; 268 &schedule;
267 } 269 }
268 }; 270 };
269 271
272 if ($@) {
270 last if $@ eq "\3async_pool terminate\2\n"; 273 last if $@ eq "\3async_pool terminate\2\n";
271 warn $@ if $@; 274 warn $@;
275 }
272 } 276 }
273} 277}
274 278
275sub async_pool(&@) { 279sub async_pool(&@) {
276 # this is also inlined into the unlock_scheduler 280 # this is also inlined into the unlock_scheduler
… …
306This makes C<schedule> I<the> generic method to use to block the current 310This makes C<schedule> I<the> generic method to use to block the current
307coroutine and wait for events: first you remember the current coroutine in 311coroutine and wait for events: first you remember the current coroutine in
308a variable, then arrange for some callback of yours to call C<< ->ready 312a variable, then arrange for some callback of yours to call C<< ->ready
309>> on that once some event happens, and last you call C<schedule> to put 313>> on that once some event happens, and last you call C<schedule> to put
310yourself to sleep. Note that a lot of things can wake your coroutine up, 314yourself to sleep. Note that a lot of things can wake your coroutine up,
311so you need to check wether the event indeed happened, e.g. by storing the 315so you need to check whether the event indeed happened, e.g. by storing the
312status in a variable. 316status in a variable.
313 317
314The canonical way to wait on external events is this: 318The canonical way to wait on external events is this:
315 319
316 { 320 {
… …
355Kills/terminates/cancels all coroutines except the currently running 359Kills/terminates/cancels all coroutines except the currently running
356one. This is useful after a fork, either in the child or the parent, as 360one. This is useful after a fork, either in the child or the parent, as
357usually only one of them should inherit the running coroutines. 361usually only one of them should inherit the running coroutines.
358 362
359Note that while this will try to free some of the main programs resources, 363Note that while this will try to free some of the main programs resources,
360you cnanot free all of them, so if a coroutine that is not the main 364you cannot free all of them, so if a coroutine that is not the main
361program calls this function, there will be some one-time resource leak. 365program calls this function, there will be some one-time resource leak.
362 366
363=cut 367=cut
364 368
365sub terminate { 369sub terminate {
… …
414once all the coroutines of higher priority and all coroutines of the same 418once all the coroutines of higher priority and all coroutines of the same
415priority that were put into the ready queue earlier have been resumed. 419priority that were put into the ready queue earlier have been resumed.
416 420
417=item $is_ready = $coroutine->is_ready 421=item $is_ready = $coroutine->is_ready
418 422
419Return wether the coroutine is currently the ready queue or not, 423Return whether the coroutine is currently the ready queue or not,
420 424
421=item $coroutine->cancel (arg...) 425=item $coroutine->cancel (arg...)
422 426
423Terminates the given coroutine and makes it return the given arguments as 427Terminates the given coroutine and makes it return the given arguments as
424status (default: the empty list). Never returns if the coroutine is the 428status (default: the empty list). Never returns if the coroutine is the
… …
610creating event callbacks that want to block. 614creating event callbacks that want to block.
611 615
612If your handler does not plan to block (e.g. simply sends a message to 616If your handler does not plan to block (e.g. simply sends a message to
613another coroutine, or puts some other coroutine into the ready queue), 617another coroutine, or puts some other coroutine into the ready queue),
614there is no reason to use C<unblock_sub>. 618there is no reason to use C<unblock_sub>.
619
620Note that you also need to use C<unblock_sub> for any other callbacks that
621are indirectly executed by any C-based event loop. For example, when you
622use a module that uses L<AnyEvent> (and you use L<Coro::AnyEvent>) and it
623provides callbacks that are the result of some event callback, then you
624must not block either, or use C<unblock_sub>.
615 625
616=cut 626=cut
617 627
618our @unblock_queue; 628our @unblock_queue;
619 629

Diff Legend

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