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/AC/DC.pm view on Meta::CPAN
use strict;
our $VERSION = 1.1;
=head1 NAME
AC::DC - Asynchronous IO Framework. plus.
=head1 SYNOPSIS
use AC::DC::IO;
view release on metacpan or search on metacpan
lib/AC/Yenta/Store/SQLite.pm view on Meta::CPAN
unique(map,sub,key)
);
create index if not exists ykvidx on ykv(map, sub, key);
pragma synchronous = 1; -- default is full(2)
pragma cache_size = 100000; -- default is 2000
vacuum;
view release on metacpan or search on metacpan
lib/ACME/QuoteDB/DB/DBI.pm view on Meta::CPAN
RaiseError => 1,
unicode => 1,
# func/pragma's may not work here,..(probably isnt' smart anyway)
#count_changes => 0,
#temp_store => 2,
#synchronous => 'OFF',
#busy_timeout => 3600000
}
)
|| croak "$QUOTES_DATABASE does not exist, or cant be created $!";
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/AFS/Command/FS.pm view on Meta::CPAN
}
if ( $operation eq 'storebehind' ) {
if ( /Default store asynchrony is (\d+) kbytes/ ) {
$default = $1;
next;
} elsif ( /Will store (.*?) according to default./ ) {
$path->_setAttribute
(
path => $1,
asynchrony => 'default',
);
delete $paths{$1};
@paths = grep($_ ne $1,@paths);
} elsif ( /Will store up to (\d+) kbytes of (.*?) asynchronously/ ) {
$path->_setAttribute
(
path => $2,
asynchrony => $1,
);
delete $paths{$2};
@paths = grep($_ ne $2,@paths);
lib/AFS/Command/FS.pm view on Meta::CPAN
}
if ( $operation eq 'storebehind' ) {
$result->_setAttribute( asynchrony => $default );
#
# This is ugly, but we get the default last, and it would be nice
# to put this value into the Path objects as well, rather than the
# string 'default'.
#
foreach my $path ( $result->getPaths() ) {
if ( defined($path->asynchrony()) && $path->asynchrony() eq 'default' ) {
$path->_setAttribute( asynchrony => $default );
}
}
}
foreach my $pathname ( keys %paths ) {
view release on metacpan or search on metacpan
pod/udebug.pod view on Meta::CPAN
The B<udebug> function returns the status of the lightweight
Ubik process for the database server process identified by
the B<port> argument that is running on the database server
machine named by the B<server> argument. The output identifies
the machines where peer database server processes are running,
which of them is the synchronization site (Ubik coordinator),
and the status of the connections between them.
=head1 OPTIONS
=over
pod/udebug.pod view on Meta::CPAN
=item B<long>
Reports additional information about each peer of the machine
named by the B<server> argument. The information appears by
default if that machine is the synchronization site.
=back
=head1 OUTPUT
pod/udebug.pod view on Meta::CPAN
=item B<amSyncSite>, B<syncSiteUntil> and B<nServers>
Indicates whether the Ubik process is the coordinator or not.
If there are multiple database sites, and the B<server> argument
names the coordinator (synchronization site), then the B<syncSiteUntil>
entry indicates the time (in seconds since the Epoch) the site will
remain coordinator even if the next attempt to maintain quorum fails.
The entry B<nServers> indicates how many sites are participating
in the quorum.
=item B<recoveryState>
If there are multiple database sites, and the B<server> argument
names the coordinator (synchronization site), then this entry will
contain a hexadecimal number that indicates the current state of the quorum.
A value of C<1f> indicates complete database synchronization, whereas a value
of C<f> means that the coordinator has the correct database but cannot contact
all secondary sites to determine if they also have it. Lesser values are
acceptable if the B<udebug> function is issued during coordinator election, but
they denote a problem if they persist. The individual flags have the
following meanings:
pod/udebug.pod view on Meta::CPAN
The time (in seconds since the Epoch) that the B<syncHost> (see above) was set.
=item B<syncVersion>
A reference to a hash containing two entries, B<epoch> and B<counter>,
indicating the version number of the database at the synchronization site,
which needs to match the version number of the local databse, indicated
by B<localVersion> (see above).
=item B<lockedPages> and B<writeLockedPages>
view release on metacpan or search on metacpan
examples/v2/vldb/syncserv view on Meta::CPAN
$AFS::CODE and print "AFS::CODE = $AFS::CODE\n";
if (defined $partition) {
$ok = $vldb->syncserv($server, $partition);
if ($AFS::CODE) { print "AFS::CODE = $AFS::CODE\n"; }
else { print "Server $server partition $partition synchronized with VLDB \n"; }
}
else {
$ok = $vldb->syncserv($server);
if ($AFS::CODE) { print "AFS::CODE = $AFS::CODE\n"; }
else { print "Server $server synchronized with VLDB \n"; }
}
view release on metacpan or search on metacpan
tools/migrationd view on Meta::CPAN
=head1 DESCRIPTION
This script acts as a server to link multiple instances of
AI::Evolve::Befunge together for the purposes of migration. This is
a cheap, easy form of parallel processing - migration allows useful
traits to propagate without requiring any synchronization, and using
minimal bandwidth.
It will run until it is killed.
Please be aware that this protocol is subject to change over time -
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
lib/AI/FuzzyEngine/Set.pm view on Meta::CPAN
$fun->[0] = \@x;
$fun->[1] = \@y;
return $fun;
}
sub synchronize_funs {
my ($class, $funA, $funB) = @_;
# change $funA, $funB directly, use their references
# \@x and \@y as part of $fun will be replaced nevertheless
my @xA = _x_of $funA;
lib/AI/FuzzyEngine/Set.pm view on Meta::CPAN
sub _minmax_of_pair_of_funs {
my ($class, $factor, $funA, $funB) = @_;
# $factor > 0: 'max' operation
# $factor < 0: 'min' operation
# synchronize interpolation points (original functions are changed)
$class->synchronize_funs( $funA, $funB );
my @x = _x_of $funA;
my @yA = _y_of $funA;
my @yB = _y_of $funB;
# my @y = List::MoreUtils::pairwise { $a*$factor > $b*$factor ?
view release on metacpan or search on metacpan
lib/AI/Genetic/Pro.pm view on Meta::CPAN
=item Memory
This module was designed to use as little memory as possible. A population
of size 10000 consisting of 92-bit vectors uses only ~24MB (C<AI::Genetic>
would use about 78MB). However - if you use MCE - there will be bigger
memory consumption. This is consequence of necessity of synchronization
between many processes.
=item Advanced options
To provide more flexibility C<AI::Genetic::Pro> supports many
view release on metacpan or search on metacpan
lib/AI/MXNet/KVStore.pm view on Meta::CPAN
AI::MXNet::KVStore - Key value store interface of MXNet.
=head1 DESCRIPTION
Key value store interface of MXNet for parameter synchronization, over multiple devices.
=cut
has 'handle' => (is => 'ro', isa => 'KVStoreHandle', required => 1);
has '_updater' => (is => 'rw', isa => 'AI::MXNet::Updater');
has '_updater_func' => (is => 'rw', isa => 'CodeRef');
lib/AI/MXNet/KVStore.pm view on Meta::CPAN
Push a single or a sequence of key-value pairs into the store.
Data consistency:
1. this function returns after adding an operator to the engine.
2. push is always called after all previous push and pull on the same
key are finished.
3. there is no synchronization between workers. One can use _barrier()
to sync all workers.
Parameters
----------
key : str or array ref of str
view release on metacpan or search on metacpan
mx_uint *out_size,
NDArrayHandle** out_array,
mx_uint *out_size,
const char*** out_array);
/*!
* \brief Perform a synchronize copy from a continugous CPU memory region.
*
* This function will call WaitToWrite before the copy is performed.
* This is useful to copy data from existing memory region that are
* not wrapped by NDArray(thus dependency not being tracked).
*
*/
int MXNDArraySyncCopyFromCPU(NDArrayHandle handle,
const void *in,
size_t size);
/*!
* \brief Perform a synchronize copy to a continugous CPU memory region.
*
* This function will call WaitToRead before the copy is performed.
* This is useful to copy data from existing memory region that are
* not wrapped by NDArray(thus dependency not being tracked).
*
int MXNDArraySyncCopyToCPU(NDArrayHandle handle,
void *in,
size_t size);
/*!
* \brief Wait until all the pending writes with respect NDArray are finished.
* Always call this before read data out synchronizely.
* \param handle the NDArray handle
* \return 0 when success, -1 when failure happens
*/
int MXNDArrayWaitToRead(NDArrayHandle handle);
/*!
* \brief Wait until all the pending read/write with respect NDArray are finished.
* Always call this before write data into NDArray synchronizely.
* \param handle the NDArray handle
* \return 0 when success, -1 when failure happens
*/
int MXNDArrayWaitToWrite(NDArrayHandle handle);
/*!
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
lib/AI/Prolog/Article.pod view on Meta::CPAN
C<O(1)> argument doesn't hold. Versions written in C are far more practical in
this regard.)
But this fails, too. The first problem is that we have duplicated data. If we
have to add additional data to the C<%loves> hash, we'll have to remember to
synchronize the hashes. The second problem is that Perl is just a little too
popular:
loves(ovid, perl).
loves(alice, perl).
loves(bob, perl).
lib/AI/Prolog/Article.pod view on Meta::CPAN
=over 4
=item * Data must often be duplicated to handle bi-directional relations.
=item * You must remember to synchronize data structures if the data changes.
=item * Often you need to change your code if your relations change.
=item * The code can get complex, leading to more bugs.
view release on metacpan or search on metacpan
lib/ALPM.pod view on Meta::CPAN
=head2 register
$DB | undef = $OBJ->register($NAME, $SIGLEVEL?)
Registers a remote synchronizable database.
=over 4
=item C<$NAME>
view release on metacpan or search on metacpan
lib/AMF/Connection.pm view on Meta::CPAN
This module has been inspired to SabreAMF PHP implementation of AMF client libraries.
AMF::Connection is meant to provide a simple AMF library to write client applications for invocation of remote services as used by most flex/AIR RIAs.
The module includes basic support for synchronous HTTP/S based RPC request-response access, where the client sends a request to the server to be processed and the server returns a response to the client containing the processing outcome. Data is sent...
AMF0 and AMF3 support is provided using the Storable::AMF module. While HTTP/S requestes to the AMF endpoint are carried out using the LWP::UserAgent module. The requests are sent using the HTTP POST method as AMF0 encoded data by default. AMF3 encod...
If encoding is set to AMF3 the Flex Messaging framework is used on returned responses content (I.e. objects casted to "flex.messaging.messages.AcknowledgeMessage" and "flex.messaging.messages.ErrorMessage" are returned).
view release on metacpan or search on metacpan
examples/githubcl-appspec.yaml view on Meta::CPAN
API rate limit exceeded. See http://developer.github.com/v3/#rate-limiting
for details.
post:
description: |
Create a fork.
Forking a Repository happens asynchronously. Therefore, you may have to wai
a short period before accessing the git objects. If this takes longer than 5
minutes, be sure to contact Support.
parameters:
- description: Name of repository owner.
in: path
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/Arc/Connection/Client.pm view on Meta::CPAN
{
my $this = shift;
return $this->_SetError("There is no command running.") unless defined $this->{_cmdclientsock};
if ($this->{protocol} == 1) {
# encrypted protocol and command connection, don't lose synchronized sasl_de/encode
$this->CommandEOF();
while ($_ = $this->CommandRead()) { $this->_Debug("read text: ".$_); };
}
$this->{_cmdclientsock}->close();
view release on metacpan or search on metacpan
ret = ARExecuteProcess(ctrl, command, NULL, NULL, &status);
}
#ifdef PROFILE
((ars_ctrl *)ctrl)->queries++;
#endif
/* if all went well, and user requested synchronous processing
* then we push the returnStatus and returnString back out to them.
* if they requested async, then we just push a 1 to indicate that the
* command to the API was successfully handled (and foo || die constructs
* will work correctly).
*/
view release on metacpan or search on metacpan
plugins/snmptt/create_NCPL_weblogic_configuration_for_SNMP.pl view on Meta::CPAN
$sthNCPL->execute or $rv = _ErrorTrapDBI ( 'sth->execute '. $sqlCOUNT, "$DBI::err ($DBI::errstr)" );
my $existingHost = $sthNCPL->fetchrow_array();
$sthNCPL->finish() or $rv = _ErrorTrapDBI ( \$objectPlugins, 'Cannot sth->finish: '. $sqlCOUNT );
unless ( $existingHost ) {
my $sqlINSERT = "INSERT INTO nagios_hosts SET server_name='$server_name', category='$category', environments='$environment', nslookup=0, synchronize=0, virtual=1, host_name='$host_name', alias='$domainname - $environment', `use`='$use_hos...
print " $sqlINSERT\n" if ( $debug );
$dbhNCPL->do( $sqlINSERT ) or $rv = _ErrorTrapDBI ( \$objectPlugins, 'Cannot dbh->do: '. $sqlINSERT ) if $rv;
$objectPlugins->pluginValues ( { stateValue => $ERRORS{CRITICAL}, error => "'$host_name' doesn't EXIST" }, $TYPE{APPEND} ) unless $rv;
}
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 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 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.