Coro
view release on metacpan or search on metacpan
NAME
Coro - the only real threads in perl
SYNOPSIS
use Coro;
async {
# some asynchronous thread of execution
print "2\n";
cede; # yield back to main
print "4\n";
};
print "1\n";
cede; # yield to coro
print "3\n";
cede; # and again
# use locking
my $lock = new Coro::Semaphore;
my $locked;
$lock->down;
$locked = 1;
$lock->up;
DESCRIPTION
For a tutorial-style introduction, please read the Coro::Intro manpage.
This manpage mainly contains reference information.
This module collection manages continuations in general, most often in
the form of cooperative threads (also called coros, or simply "coro" in
the documentation). They are similar to kernel threads but don't (in
general) run in parallel at the same time even on SMP machines. The
specific flavor of thread offered by this module also guarantees you
that it will not switch between threads unless necessary, at
easily-identified points in your program, so locking and parallel access
are rarely an issue, making thread programming much safer and easier
than using other thread models.
Unlike the so-called "Perl threads" (which are not actually real threads
but only the windows process emulation (see section of same name for
more details) ported to UNIX, and as such act as processes), Coro
provides a full shared address space, which makes communication between
threads very easy. And coro threads are fast, too: disabling the Windows
process emulation code in your perl and using Coro can easily result in
a two to four times speed increase for your programs. A parallel matrix
multiplication benchmark (very communication-intensive) runs over 300
times faster on a single core than perls pseudo-threads on a quad core
using all four cores.
Coro achieves that by supporting multiple running interpreters that
share data, which is especially useful to code pseudo-parallel processes
and for event-based programming, such as multiple HTTP-GET requests
running concurrently. See Coro::AnyEvent to learn more on how to
integrate Coro into an event-based environment.
In this module, a thread is defined as "callchain + lexical variables +
some package variables + C stack), that is, a thread has its own
callchain, its own set of lexicals and its own set of perls most
important global variables (see Coro::State for more configuration and
background info).
See also the "SEE ALSO" section at the end of this document - the Coro
module family is quite large.
CORO THREAD LIFE CYCLE
During the long and exciting (or not) life of a coro thread, it goes
through a number of states:
1. Creation
The first thing in the life of a coro thread is it's creation -
obviously. The typical way to create a thread is to call the "async
BLOCK" function:
async {
# thread code goes here
};
You can also pass arguments, which are put in @_:
async {
print $_[1]; # prints 2
} 1, 2, 3;
The idle pool size is limited to 8 idle coros (this can be adjusted
by changing $Coro::POOL_SIZE), but there can be as many non-idle
coros as required.
If you are concerned about pooled coros growing a lot because a
single "async_pool" used a lot of stackspace you can e.g.
"async_pool { terminate }" once per second or so to slowly replenish
the pool. In addition to that, when the stacks used by a handler
grows larger than 32kb (adjustable via $Coro::POOL_RSS) it will also
be destroyed.
STATIC METHODS
Static methods are actually functions that implicitly operate on the
current coro.
schedule
Calls the scheduler. The scheduler will find the next coro that is
to be run from the ready queue and switches to it. The next coro to
be run is simply the one with the highest priority that is longest
in its ready queue. If there is no coro ready, it will call the
$Coro::idle hook.
Please note that the current coro will *not* be put into the ready
queue, so calling this function usually means you will never be
called again unless something else (e.g. an event handler) calls
"->ready", thus waking you up.
This makes "schedule" *the* generic method to use to block the
current coro and wait for events: first you remember the current
coro in a variable, then arrange for some callback of yours to call
"->ready" on that once some event happens, and last you call
"schedule" to put yourself to sleep. Note that a lot of things can
wake your coro up, so you need to check whether the event indeed
happened, e.g. by storing the status in a variable.
See HOW TO WAIT FOR A CALLBACK, below, for some ways to wait for
callbacks.
cede
"Cede" to other coros. This function puts the current coro into the
ready queue and calls "schedule", which has the effect of giving up
the current "timeslice" to other coros of the same or higher
priority. Once your coro gets its turn again it will automatically
be resumed.
This function is often called "yield" in other languages.
Coro::cede_notself
Works like cede, but is not exported by default and will cede to
*any* coro, regardless of priority. This is useful sometimes to
ensure progress is made.
terminate [arg...]
Terminates the current coro with the given status values (see
cancel). The values will not be copied, but referenced directly.
Coro::on_enter BLOCK, Coro::on_leave BLOCK
These function install enter and leave winders in the current scope.
The enter block will be executed when on_enter is called and
whenever the current coro is re-entered by the scheduler, while the
leave block is executed whenever the current coro is blocked by the
scheduler, and also when the containing scope is exited (by whatever
means, be it exit, die, last etc.).
*Neither invoking the scheduler, nor exceptions, are allowed within
those BLOCKs*. That means: do not even think about calling "die"
without an eval, and do not even think of entering the scheduler in
any way.
Since both BLOCKs are tied to the current scope, they will
automatically be removed when the current scope exits.
These functions implement the same concept as "dynamic-wind" in
scheme does, and are useful when you want to localise some resource
to a specific coro.
They slow down thread switching considerably for coros that use them
(about 40% for a BLOCK with a single assignment, so thread switching
is still reasonably fast if the handlers are fast).
These functions are best understood by an example: The following
function will change the current timezone to
"Antarctica/South_Pole", which requires a call to "tzset", but by
using "on_enter" and "on_leave", which remember/change the current
timezone and restore the previous value, respectively, the timezone
is only changed for the coro that installed those handlers.
use POSIX qw(tzset);
async {
my $old_tz; # store outside TZ value here
Coro::on_enter {
$old_tz = $ENV{TZ}; # remember the old value
$ENV{TZ} = "Antarctica/South_Pole";
tzset; # enable new value
};
Coro::on_leave {
$ENV{TZ} = $old_tz;
tzset; # restore old value
};
# at this place, the timezone is Antarctica/South_Pole,
# without disturbing the TZ of any other coro.
};
This can be used to localise about any resource (locale, uid,
current working directory etc.) to a block, despite the existence of
other coros.
Another interesting example implements time-sliced multitasking
using interval timers (this could obviously be optimised, but does
the job):
# "timeslice" the given block
sub timeslice(&) {
use Time::HiRes ();
Coro::on_enter {
current->prio (PRIO_HIGH);
The idle coro thread ($Coro::idle) always has a lower priority than
any existing coro.
Changing the priority of the current coro will take effect
immediately, but changing the priority of a coro in the ready queue
(but not running) will only take effect after the next schedule (of
that coro). This is a bug that will be fixed in some future version.
$newprio = $coro->nice ($change)
Similar to "prio", but subtract the given value from the priority
(i.e. higher values mean lower priority, just as in UNIX's nice
command).
$olddesc = $coro->desc ($newdesc)
Sets (or gets in case the argument is missing) the description for
this coro thread. This is just a free-form string you can associate
with a coro.
This method simply sets the "$coro->{desc}" member to the given
string. You can modify this member directly if you wish, and in
fact, this is often preferred to indicate major processing states
that can then be seen for example in a Coro::Debug session:
sub my_long_function {
local $Coro::current->{desc} = "now in my_long_function";
...
$Coro::current->{desc} = "my_long_function: phase 1";
...
$Coro::current->{desc} = "my_long_function: phase 2";
...
}
GLOBAL FUNCTIONS
Coro::nready
Returns the number of coro that are currently in the ready state,
i.e. that can be switched to by calling "schedule" directory or
indirectly. The value 0 means that the only runnable coro is the
currently running one, so "cede" would have no effect, and
"schedule" would cause a deadlock unless there is an idle handler
that wakes up some coro.
my $guard = Coro::guard { ... }
This function still exists, but is deprecated. Please use the
"Guard::guard" function instead.
unblock_sub { ... }
This utility function takes a BLOCK or code reference and "unblocks"
it, returning a new coderef. Unblocking means that calling the new
coderef will return immediately without blocking, returning nothing,
while the original code ref will be called (with parameters) from
within another coro.
The reason this function exists is that many event libraries (such
as the venerable Event module) are not thread-safe (a weaker form of
reentrancy). This means you must not block within event callbacks,
otherwise you might suffer from crashes or worse. The only event
library currently known that is safe to use without "unblock_sub" is
EV (but you might still run into deadlocks if all event loops are
blocked).
Coro will try to catch you when you block in the event loop ("FATAL:
$Coro::idle blocked itself"), but this is just best effort and only
works when you do not run your own event loop.
This function allows your callbacks to block by executing them in
another coro where it is safe to block. One example where blocking
is handy is when you use the Coro::AIO functions to save results to
disk, for example.
In short: simply use "unblock_sub { ... }" instead of "sub { ... }"
when creating event callbacks that want to block.
If your handler does not plan to block (e.g. simply sends a message
to another coro, or puts some other coro into the ready queue),
there is no reason to use "unblock_sub".
Note that you also need to use "unblock_sub" for any other callbacks
that are indirectly executed by any C-based event loop. For example,
when you use a module that uses AnyEvent (and you use
Coro::AnyEvent) and it provides callbacks that are the result of
some event callback, then you must not block either, or use
"unblock_sub".
$cb = rouse_cb
Create and return a "rouse callback". That's a code reference that,
when called, will remember a copy of its arguments and notify the
owner coro of the callback.
See the next function.
@args = rouse_wait [$cb]
Wait for the specified rouse callback (or the last one that was
created in this coro).
As soon as the callback is invoked (or when the callback was invoked
before "rouse_wait"), it will return the arguments originally passed
to the rouse callback. In scalar context, that means you get the
*last* argument, just as if "rouse_wait" had a "return ($a1, $a2,
$a3...)" statement at the end.
See the section HOW TO WAIT FOR A CALLBACK for an actual usage
example.
HOW TO WAIT FOR A CALLBACK
It is very common for a coro to wait for some callback to be called.
This occurs naturally when you use coro in an otherwise event-based
program, or when you use event-based libraries.
These typically register a callback for some event, and call that
callback when the event occurred. In a coro, however, you typically want
to just wait for the event, simplyifying things.
For example "AnyEvent->child" registers a callback to be called when a
specific child has exited:
my $child_watcher = AnyEvent->child (pid => $pid, cb => sub { ... });
But from within a coro, you often just want to write this:
my $status = wait_for_child $pid;
Coro offers two functions specifically designed to make this easy,
( run in 2.273 seconds using v1.01-cache-2.11-cpan-5837b0d9d2c )