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.34.0                                       2022-02-06                                          Util(3pm)