NAME

       Coro::Util - various utility functions.

SYNOPSIS

        use Coro::Util;

DESCRIPTION

       This module implements various utility functions, mostly replacing perl functions by non-blocking
       counterparts.

       Many of these functions exist for the sole purpose of emulating existing interfaces, no matter how bad or
       limited they are (e.g. no IPv6 support).

       This module is an AnyEvent user. Refer to the AnyEvent documentation to see how to integrate it into your
       own programs.

       $ipn = Coro::Util::inet_aton $hostname || $ip
           Works  almost  exactly  like its "Socket::inet_aton" counterpart, except that it does not block other
           coroutines.

           Does not handle multihomed hosts or IPv6 - consider using  "AnyEvent::Socket::resolve_sockaddr"  with
           the Coro rouse functions instead.

       gethostbyname, gethostbyaddr
           Work  similarly  to  their  Perl  counterparts,  but  do  not block. Uses "AnyEvent::Util::inet_aton"
           internally.

           Does not handle multihomed hosts or IPv6 -  consider  using  "AnyEvent::Socket::resolve_sockaddr"  or
           "AnyEvent::DNS::reverse_lookup" with the Coro rouse functions instead.

       @result = Coro::Util::fork_eval { ... }, @args
           Executes  the  given  code  block  or  code reference with the given arguments in a separate process,
           returning the results. The return values must be serialisable with Coro::Storable. It may, of course,
           block.

           Note that using event handling in the sub is not usually a good idea as you will inherit a mixed  set
           of watchers from the parent.

           Exceptions will be correctly forwarded to the caller.

           This  function is useful for pushing cpu-intensive computations into a different process, for example
           to take advantage of multiple CPU's. Its also  useful  if  you  want  to  simply  run  some  blocking
           functions  (such  as system()) and do not care about the overhead enough to code your own pid watcher
           etc.

           This function might keep a pool of processes in some future version, as fork can be  rather  slow  in
           large processes.

           You  should  also  look at "AnyEvent::Util::fork_eval", which is newer and more compatible to totally
           broken Perl implementations such as the one from ActiveState.

           Example: execute some external program (convert image to rgba raw form) and add  a  long  computation
           (extract  the  alpha  channel)  in  a  separate  process,  making  sure that never more then $NUMCPUS
           processes are being run.

              my $cpulock = new Coro::Semaphore $NUMCPUS;

              sub do_it {
                 my ($path) = @_;

                 my $guard = $cpulock->guard;

                 Coro::Util::fork_eval {
                    open my $fh, "convert -depth 8 \Q$path\E rgba:"
                       or die "$path: $!";

                    local $/;
                    # make my eyes hurt
                    pack "C*", unpack "(xxxC)*", <$fh>
                 }
              }

              my $alphachannel = do_it "/tmp/img.png";

AUTHOR/SUPPORT/CONTACT

          Marc A. Lehmann <schmorp@schmorp.de>
          http://software.schmorp.de/pkg/Coro.html

perl v5.38.2                                       2024-03-31                                          Util(3pm)