view release on metacpan or  search on metacpan

lib/Async/Queue.pm  view on Meta::CPAN

}


=head1 NAME

Async::Queue - control concurrency of asynchronous tasks

=head1 VERSION

Version 0.021

lib/Async/Queue.pm  view on Meta::CPAN

=over

=item L<AnyEvent::FIFO>

The goal of L<AnyEvent::FIFO> is the same as that of L<Async::Queue>: to control concurrency level of asynchronous tasks.
The big difference is that L<AnyEvent::FIFO> is a queue of subroutines while L<Async::Queue> is a queue of tasks (data).
In L<Async::Queue>, worker subroutine is registered with the object in advance.
In L<AnyEvent::FIFO>, it is workers that are pushed to the queue.

You can emulate L<AnyEvent::FIFO> with L<Async::Queue> by pushing subroutine references to it as tasks.

 view release on metacpan or  search on metacpan

examples/stress/lib/Stress/Workload.pm  view on Meta::CPAN

        my $job = "job_${seq}";
        # Pre-increment pushed BEFORE the await. Otherwise the Perl event
        # loop can fire the consumer's BLPOP-response continuation before
        # the driver's LPUSH-response continuation, creating a transient
        # popped > pushed state even though Redis itself never popped a
        # phantom message. By bumping pushed synchronously, any BLPOP
        # wakeup necessarily sees pushed >= corresponding popped.
        #
        # We do NOT decrement on LPUSH failure: under chaos, an await can
        # fail after the bytes reached Redis (response lost on disconnect),
        # so we can't reliably know whether the push actually happened.

 view release on metacpan or  search on metacpan

lib/Async/ResourcePool.pm  view on Meta::CPAN

package Async::ResourcePool v0.1.3;

=head1 NAME

Async::ResourcePool - Resource pooling for asynchronous programs.

=head1 DESCRIPTION

This module implements the simple functionality of creating a source pool for
event-based/asynchronous programs.  It provides consumers with the ability to
have some code execute whenever a resource happens to be ready.  Further, it
allows resources to be categorized (by label) and limited as such.

=cut

 view release on metacpan or  search on metacpan

lib/Async/Stream.pm  view on Meta::CPAN

	return $self;
}

=head2 map($transformer)

Method makes synchronous transformation for stream, like usual map for array.

  $stream->map(sub { $_ * 2 })->to_arrayref(sub {print @{$_[0]}});

=cut
sub map {

 view release on metacpan or  search on metacpan

lib/Async/Template.pm  view on Meta::CPAN

    };


=head1 DESCRIPTION

Async::Template is the same as Template Toolkit with asynchronous interface and
with asynchronous operators ASYNC/AWAIT which can be used with any event
management system (like L<AnyEvent>).

To refer Template Toolkit language syntax, configure options, params and other
documentation folow this link L<Template>.

Operators like ASYNC/AWAIT itself is not an function or something wich applied
locally at the place where it is used in the code. Such operators affect all
the code generation and the execution sequences. Any block of code cease to be
a block if at least one async operator is exists in it. Loops, blocks,
conditions, switches, and so on become different in synchronous and asynchronous
implementations.

For example a synchronous loop is continuous sequence which at the end of loop
has a transition to the begin of the loop. But the asynchronous loop is not
a continuos sequence and to do transition to the begin of loop typical loop
operators can not be used because begin and end of loop located in different
unjoined betwen each other code sequences (in a different fuctions).
This is because at the middle of the loop at the place of async operator
presents a finish of the execution and return. This return must be supported
by each of parent block statement. Execution must be returned to the very top
of the execution - to the event loop. And after awaited event condition is
reached the execution must continue from that place from which it was returned.

Therefore to develop a compiler with asynchronous operators it need to have
different synchronous and asynchronous implementation for each block operator of
language and many more. And for synchronous an asynchronous function call. This
library represent itself compiler with modified grammar based on Template
Toolkit. This library provides implementation of asynchronous operators and the
code generation and asynchronous stack management and so on, uses itself as
library for asynchronous sequences and uses Template Toolkit as library for
execution generic synchronous sequences and also uses parts modified to be
asynchronous.


=head2 SYNC AND ASYNC BLOCKS 

Continuous sequence of execution is tеaring at the place of AWAIT operator.
The block is not only BLOCK operator statement but also IF, WHILE and etc...

Any block become asynchronous if it have at least one AWAIT operator or
another asynchronous block.

Any block is synchronous if it does not contain AWAIT operator or another
asynchronous block even if it has any amount of ASYNC opeartor

Any block does not become asynchronous if it has ASYNC operator inside
(if it has no AWAIT operator nor one or more asynchronous block).


=head2 TODO

As mentioned above, each block of code must be implemented differently
therefore this library has asynchronous implementation for most of block
operators of Template Toolkit language but not all yet.

The block operators which is not implemented as asynchronous will work anyway
with synchronous sequences (i.e. without AWAIT operator inside of it). 

Here the list of Template Toolkit operators async implementation of which does
not checked and/or implemented:

NEXT LAST STOP

lib/Async/Template.pm  view on Meta::CPAN

Serguei Okladnikov E<lt>oklaspec@gmail.comE<gt>

This L<Async::Template> package uses "Template Toolkit" (L<Template>)
as dependency and contains small amount modified parts of "Template Toolkit"
(modified grammar and continuous synchronous code which was necessary
to split for execution asynchronous sequences). The "Template Toolkit" was
written by Andy Wardley E<lt>abw@wardley.orgE<gt> and contributors, see
Template::Manual::Credits for details and repos contributors sections.


=head1 LICENSE 

 view release on metacpan or  search on metacpan

lib/Async/Util.pm  view on Meta::CPAN

=pod

=head1 NAME

Async::Util - Utilities for common asynchronous programming tasks

=head1 SYNOPSIS

    use Async::Util qw(amap azipmap achain);

    # async map
    amap(
        inputs => [ 'foo', 'bar' ],
        action => \&something_asynchronous,
        cb     => \&do_this_at_the_end,
    );

    # invoke action on the corresponding input
    azipmap(
        inputs  => [ 1, 1, 1 ],
        actions => [
            ... # asynchronous subs
        ],
        cb     => \&do_this_at_the_end,
    );

    # execute steps in order
    achain(
        input => 2,
        steps => [
            ... # asynchronous subs
        ],
        cb    => \&do_this_at_the_end,
    );

Examples using AnyEvent:

lib/Async/Util.pm  view on Meta::CPAN

    my ($res, $err) = $cv->recv; # $res is 6

=head1 DESCRIPTION

C<Async::Util> provides functionality for common tasks that come up when doing
asynchronous programming. This module's functions often take code refs. These
code refs are invoked with two arguments: the input and a callback to be
invoked on completion. When the provided callback is invoked it should be
passed an output argument and an optional error.

=head1 FUNCTIONS

=head2 amap

C<amap> is an asynchronous version of map:

    amap(
        inputs    => <ARRAY_REF>,
        action    => <CODE_REF>,
        cb        => <CODE_REF>,

 view release on metacpan or  search on metacpan

lib/Asynchat.pm  view on Meta::CPAN

    $channel->found_terminator( ... )

 
=head1 DESCRIPTION

Asynchat builds on Asyncore, simplifying asynchronous clients and servers and making it easier to handle protocols whose elements are terminated by arbitrary strings, or are of variable length. 
 
Asyncore is a basic infrastructure for asyncronous socket programming. It provides an implementation of "reactive socket" and it provides hooks for handling events. Code must be written into these hooks (handlers).
 
Asynchat is intended as an abstract class. Override collect_incoming_data() and found_terminator() in a subclass to provide the implementation of the protocol you are writing.
 

 view release on metacpan or  search on metacpan

lib/Asyncore.pm  view on Meta::CPAN

__END__


=head1 NAME

Asyncore - basic infrastracture for asynchronous socket services

=head1 SYNOPSIS

    use Asyncore;
    use base qw( Asyncore::Dispatcher );

 view release on metacpan or  search on metacpan

eg/p2p_sync.pl  view on Meta::CPAN

# In a real scenario, you would first get the root CID via $at->get_repo_head($did)
my $root_cid_str = 'bafyreia2izlj2wnxrwzoh4skwlahyc2conqdjugbsvy6eu5qtyc7ws6dsu';
say "Fetching repository block $root_cid_str via P2P...";
my $f = $at->get_block( $root_cid_str, $peer_id ? $peer_id->to_string : undef );

# Since this is an asynchronous operation, we drive the loop until the block arrives
# or the request fails.
while ( !$f->is_ready ) {
    $node->host->io_utils->loop->loop_once(0.1);
}
if ( $f->is_done ) {

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

lib/AtteanX/Query/Cache.pm  view on Meta::CPAN

This is an alpha release of a system that is able to intercept SPARQL
queries if deployed in a proxy, and analyze the queries so that the
query can be evaluated on the proxy. It can look up in a cache on the
proxy, send parts of the query on to the remote endpoint, use Linked
Data Fragments when appropriate and so on. The analyzer may also
decide to prefetch certain data asynchronously.

It is known at present to have insufficient performance for any
practical use, but is released anyway as an alpha.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use 5.005;
use strict 'vars';

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

}
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.85  Thu Jun 11 09:31:00 CET 2009
  - Document findsym for the sake of mod_perl. (David Wheeler)
  - Remove unused variable. (David Wheeler)

0.84  Wed Jun 10 15:14:00 CET 2009
  - Core-CPAN synchronization

0.83  Fri Mar 13 15:14:00 CET 2009
  - Re-add a TODO marker in the tests that would fail on 5.6.2.

0.82  Wed Mar 11 17:17:00 CET 2009

 view release on metacpan or  search on metacpan

lib/Audio/Analyzer.pm  view on Meta::CPAN

Overrides seek_step. No default.

=item seek_step 

How far to move forward every iteration. Overridden by fps. Default is not to do
additional seeking which will not create audio/visual synchronized output.

=item scaler

Use another scaler class besides the default Audio::Analyzer::ACurve; 
pass in either a string of the name of the class that will be scaling or undef

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

}
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

}
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

utils/auto-debug-module.example-gdb  view on Meta::CPAN

/usr/lib/perl5/5.8.8/i386-linux-thread-multi/CORE/perl.h:163:1: warning: this is the location of the previous definition
gcc -c  -I. -D_REENTRANT -D_GNU_SOURCE -fno-strict-aliasing -pipe -Wdeclaration-after-statement -I/usr/local/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/gdbm -g   -DVERSION=\"1.04\" -DXS_VERSION=\"1.04\" -fPIC "-I/usr/lib/perl5/...
Running Mkbootstrap for Audio::FindChunks ()
chmod 644 FindChunks.bs
rm -f blib/arch/auto/Audio/FindChunks/FindChunks.so
gcc  -shared -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m32 -march=i386 -mtune=generic -fasynchronous-unwind-tables -L/usr/local/lib FindChunks.o wavestats.o  -o blib/arch/auto/Audio/FindChunk...
	     	\
	  
chmod 755 blib/arch/auto/Audio/FindChunks/FindChunks.so
cp FindChunks.bs blib/arch/auto/Audio/FindChunks/FindChunks.bs
chmod 644 blib/arch/auto/Audio/FindChunks/FindChunks.bs

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

Revision history for Perl extension Audio::MPEG.

0.04  Sun Jun 17 23:47 2001
	- fixed ID3 V2 errors (improper handling of lost synchronization)
	- added err_ok() function to Decode

0.03  Sun Jun 17 11:30 2001
	- updated documentation (include scalar->array->scalar info)
	- added more tests

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

 view release on metacpan or  search on metacpan

lib/Audio/Nama.pm  view on Meta::CPAN

    If midish is configured to use ALSA (default on Linux systems) then ``filename'' should contain the ALSA sequencer port, as listed by ``aseqdump -l'', (eg. ``28:0'', ``FLUID Synth (qsynth)''). If ``nil'' is given instead of the path, then the por...
ddel devnum
    detach device number ``devnum'' 
dmtcrx devnum
    use device number ``devnum'' as MTC source. In this case, midish will relocate, start and stop according to incoming MTC messages. Midish will generate its clock ticks from MTC, meaning that it will run at the same speed as the MTC device. This i...
dmmctx { devnum1 devnum2 ... }
    Configure the given devices to transmit MMC start, stop and relocate messages. Useful to control MMC-capable audio applications from midish. By default, devices transmit MMC. 
dclktx { devnum1 devnum2 ... }
    Configure the given devices to transmit MIDI clock information (MIDI ticks, MIDI start and MIDI stop events). Useful to synchronize an external sequencer to midish. 
dclkrx devnum
    set device number ``devnum'' to be the master MIDI clock source. It will give midish MIDI ticks, MIDI start and MIDI stop events. This useful to synchronize midish to an external sequencer. If ``devnum'' is ``nil'', then the internal clock will b...
dclkrate devnum ticrate
    set the number of ticks in a whole note that are transmitted to the MIDI device (if dclktx was called for it). Default value is 96 ticks. This is the standard MIDI value and its not recommended to change it. 
dinfo devnum
    Print some information about the MIDI device. 
dixctl devnum list

 view release on metacpan or  search on metacpan

MPG123.pm  view on Meta::CPAN

Most methods can be either BLOCKING (they wait until they get an answer,
which usually takes half a mpeg frame of playing time), NONBLOCKING (the
functions return as soon as they send their message, which is usallly
instant) or CACHING (the method returns some cached data which only gets
refreshed by an asynchronous STAT event or an explicit call to C<state>).

=over 4

=item new [parameter => value, ...]