Result:
found more than 814 distributions - search limited to the first 2001 files matching your query
( run in 0.611 )
Net-Squid-Auth-Plugin-SimpleLDAP
view release on metacpan or search on metacpan
lib/Net/Squid/Auth/Plugin/SimpleLDAP.pm view on Meta::CPAN
=head2 Internet Relay Chat
You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is,
please read this excellent guide: L<http://en.wikipedia.org/wiki/Internet_Relay_Chat>. Please
be courteous and patient when talking to us, as we might be busy or sleeping! You can join
those networks/channels and get help:
=over 4
=item *
Net-Telnet-Gearman
view release on metacpan or search on metacpan
lib/Net/Telnet/Gearman/Function.pm view on Meta::CPAN
use strict;
use warnings;
use base qw/Class::Accessor::Fast/;
use Scalar::Util qw(looks_like_number);
__PACKAGE__->mk_accessors(qw/name queue busy free running/);
sub parse_line {
my ( $package, $line ) = @_;
my ( $name, $queue, $busy, $running ) = split /[\s]+/, $line;
return
if !looks_like_number($queue)
|| !looks_like_number($busy)
|| !looks_like_number($running);
my $free = $running - $busy;
return $package->new(
{
name => $name,
queue => $queue,
busy => $busy,
free => $free,
running => $running,
}
);
}
lib/Net/Telnet/Gearman/Function.pm view on Meta::CPAN
print Dumper @functions
# $VAR1 = bless(
# {
# 'busy' => 10,
# 'free' => 0,
# 'name' => 'resize_image',
# 'queue' => 74,
# 'running' => 10
# },
lib/Net/Telnet/Gearman/Function.pm view on Meta::CPAN
=head2 queue
Returns the amount of queued jobs for this function.
=head2 busy
Returns the amount of workers currently working on this function.
=head2 free
Net-Tomcat
view release on metacpan or search on metacpan
lib/Net/Tomcat/Connector/Statistics.pm view on Meta::CPAN
package Net::Tomcat::Connector::Statistics;
use strict;
use warnings;
our @ATTR = qw(max_threads current_thread_count current_thread_busy max_processing_time
processing_time request_count error_count bytes_received bytes_sent);
foreach my $attr ( @ATTR ) {{
no strict 'refs';
*{ __PACKAGE__ . "::$attr" } = sub { my $self = shift; return $self->{$attr} }
lib/Net/Tomcat/Connector/Statistics.pm view on Meta::CPAN
=head3 current_thread_count
Returns the number of threads currently in use by the connector.
=head3 current_thread_busy
Returns the number of threads currently marked busy by the connector.
=head3 max_processing_time
Returns the maximum request processing time for the connector.
Net-UPS
view release on metacpan or search on metacpan
lib/Net/UPS.pm view on Meta::CPAN
=back
=head1 BUGS AND KNOWN ISSUES
No bugs are known of as of this release. If you think you found a bug, document it at http://rt.cpan.org/NoAuth/Bugs.html?Dist=Net-UPS. It's more likely to get noticed in there than in my busy inbox.
=head1 TODO
There are still a lot of features UPS.com offers in its Online Tools API that Net::UPS doesn't handle. This is the list of features that need to be supported before Net::UPS can claim full compliance.
Net-Waiter
view release on metacpan or search on metacpan
lib/Net/Waiter.pm view on Meta::CPAN
$self->{ 'PREFORK' } = abs( $pf );
$self->{ 'MAXFORK' } = abs( $pf ) unless $mf > 0;
}
# timeout cap
$self->{ 'TIMEOUT' } = 1 if $self->{ 'TIMEOUT' } < 1; # avoid busyloop
$self->{ 'TIMEOUT' } = 3600 if $self->{ 'TIMEOUT' } > 3600; # 1 hour max should be enough :)
$self->{ 'PX_IDLE' } = 31 if $self->{ 'PX_IDLE' } < 1;
bless $self, $class;
lib/Net/Waiter.pm view on Meta::CPAN
$SIG{ 'CHLD' } = sub { $self->__sig_child(); };
$SIG{ 'HUP' } = sub { $self->__sig_hup(); };
$SIG{ 'USR1' } = sub { $self->__sig_usr1(); };
$SIG{ 'USR2' } = sub { $self->__sig_usr2(); };
$SIG{ 'RTMIN' } = sub { $self->__sig_kid_idle() };
$SIG{ 'RTMAX' } = sub { $self->__sig_kid_busy() };
srand();
$self->on_server_begin();
lib/Net/Waiter.pm view on Meta::CPAN
last if $self->{ 'BREAK_MAIN_LOOP' };
if( $self->{ 'PREFORK' } > 0 )
{
$self->__run_prefork( $server_socket );
sleep(4); # will be interrupted by busy/free signals
}
else
{
$self->__run_forking( $server_socket );
# no need for sleep since, select/accept will block for a while (4 sec)
lib/Net/Waiter.pm view on Meta::CPAN
$SIG{ 'TERM' } = sub { $self->break_main_loop(); };
$SIG{ 'HUP' } = sub { $self->__child_sig_hup(); };
$SIG{ 'USR1' } = sub { $self->__child_sig_usr1(); };
$SIG{ 'USR2' } = sub { $self->__child_sig_usr2(); };
$SIG{ 'RTMIN' } = sub { $self->__sig_kid_idle() };
$SIG{ 'RTMAX' } = sub { $self->__sig_kid_busy() };
# ignored here, if smb needs it, should reinstall
$SIG{ 'CHLD' } = 'IGNORE';
$self->{ 'SHA' } = new IPC::Shareable key => $self->{ 'SHA_KEY' } or die "fatal: cannot attach shared memory segment\n";
srand();
$client_socket->autoflush( 1 );
$self->on_child_start();
$self->im_busy();
$self->on_process( $client_socket );
$self->on_close( $client_socket );
$client_socket->close();
$self->im_idle();
lib/Net/Waiter.pm view on Meta::CPAN
my $server_socket = shift;
my $prefork_count = $self->{ 'PREFORK' };
my $kk = $self->{ 'KIDS' }; # kids k'ount ;)
my $bk = $self->get_busy_kids_count(); # busy count
my $ik = $kk - $bk; # idle kids count
my $tk = $prefork_count;
#$tk = $kk + $prefork_count / 2 if $kk > $prefork_count and $ik < ( 1 + $prefork_count / 10 );
$tk = $kk + $prefork_count if $ik <= ( 1 + $kk / 10 );
lib/Net/Waiter.pm view on Meta::CPAN
$self->{ 'STAT' }{ 'IDLE_FREQ' }{ int( $ik / 5 ) * 5 }++ if $bk > 0;
$self->__prefork_print_stat() if $self->{ 'DEBUG' };
$__prefork_next_stat = time() + 4;
}
my $tbk = $self->{ 'STAT' }{ 'BUSY_COUNT' };
$self->log_debug( "debug: kids: $kk busy: $bk idle: $ik to_fork: $tk will_fork?: $kk < $tk total busy count: $tbk" );
while( $self->{ 'KIDS' } < $tk )
{
my $pid;
$pid = fork();
lib/Net/Waiter.pm view on Meta::CPAN
$SIG{ 'TERM' } = sub { $self->break_main_loop(); };
$SIG{ 'HUP' } = sub { $self->__child_sig_hup(); };
$SIG{ 'USR1' } = sub { $self->__child_sig_usr1(); };
$SIG{ 'USR2' } = sub { $self->__child_sig_usr2(); };
$SIG{ 'RTMIN' } = sub { $self->__sig_kid_idle() };
$SIG{ 'RTMAX' } = sub { $self->__sig_kid_busy() };
# ignored here, if smb needs it, should reinstall
$SIG{ 'CHLD' } = 'IGNORE';
$self->{ 'SHA' } = new IPC::Shareable key => $self->{ 'SHA_KEY' } or die "fatal: cannot attach shared memory segment\n";
lib/Net/Waiter.pm view on Meta::CPAN
my $sockport = $client_socket->sockport();
$self->on_accept_ok( $client_socket );
$self->{ 'BUSY_COUNT' }++;
$self->im_busy();
$client_socket->autoflush( 1 );
my $res = $self->on_process( $client_socket );
$self->on_close( $client_socket );
$client_socket->close();
$self->im_idle();
lib/Net/Waiter.pm view on Meta::CPAN
my $self = shift;
return exists $self->{ 'CLIENT_SOCKET' } ? $self->{ 'CLIENT_SOCKET' } : undef;
}
sub get_busy_kids_count
{
my $self = shift;
return wantarray ? ( $self->{ 'KIDS_BUSY' }, $self->{ 'KIDS' } ) : $self->{ 'KIDS_BUSY' };
}
lib/Net/Waiter.pm view on Meta::CPAN
return () if $self->is_child();
return keys %{ $self->{ 'KID_PIDS' } || {} };
}
sub im_busy
{
my $self = shift;
return $self->__im_in_state( '*' );
}
lib/Net/Waiter.pm view on Meta::CPAN
$SIG{ 'RTMIN' } = sub { $self->__sig_kid_idle() };
}
# used only for waking up preforked servers main loop sleep
sub __sig_kid_busy
{
my $self = shift;
$SIG{ 'RTMAX' } = sub { $self->__sig_kid_busy() };
}
##############################################################################
sub on_server_begin
lib/Net/Waiter.pm view on Meta::CPAN
=head2 get_client_socket()
Returns connected client socket.
=head2 get_busy_kids_count()
Returns the count of all forked busy processes (which are already accepted connection).
In array contect returns two integers: busy process count and all forked processes count.
This method is accessible from parent and all forked processes and reflect all processes.
Returns client (connected) socket object. Valid in kids only, otherwise returns undef.
=head2 get_kid_pids()
Net-Whois
view release on metacpan or search on metacpan
=head1 DESCRIPTION
Net::Whois::Domain new() attempts to retrieve and parse the given
domain's "whois" information from the InterNIC (whois.internic.net).
If the server could not be contacted, is too busy, or otherwise does not process
the query then the constructor does not return a reference and your object is undefined.
If the constructor returns a reference, that reference can be used to access the various
attributes of the domains' whois entry assuming that there was a match.
The member function ok returns 1 if a match 0 if no match.
Net-Wire10
view release on metacpan or search on metacpan
lib/Net/Wire10.pm view on Meta::CPAN
}
# Fail if currently connected to a streaming data reader
sub _check_streaming {
my $self = shift;
$self->_vanilla_error("Connection is busy streaming") if $self->{streaming};
}
# Connects to the database server
sub _connect {
my $self = shift;
Net-YMSG
view release on metacpan or search on metacpan
}
=head2 $yahoo->change_state($busy, $status_message)
This method sets the I<status messages> for the current user. 'Status message' is set by C<$status_message>. 'Busy icon' is set by the numerical value of C<$busy>.
The C<$busy> should be called with following arguments:
0 - I'm Available
1 - Busy
2 - Sleep
=cut
sub change_state
{
my $self = shift;
my $busy = shift;
my $message = join '', @_;
my $server = $self->handle;
my $event = $self->create('ChangeState');
$event->status_code(99); # 99 : Custom status
$event->busy($busy);
$event->body($message);
$server->send($event->to_raw_string, 0);
}
my $status_code = shift || 0;
my $server = $self->handle;
my $event = $self->create('ChangeState');
$event->status_code($status_code);
$event->busy(1);
$server->send($event->to_raw_string, 0);
}
id => 'yahoo_id',
password => 'password',
);
$yahoo->login or die "Can't login Yahoo!Messenger";;
$yahoo->change_state(IN_BUSY, q{I'm very busy now!});
sleep 5;
__END__
=head2 Become Invisible
Net-YahooMessenger
view release on metacpan or search on metacpan
lib/Net/YahooMessenger.pm view on Meta::CPAN
$event->body($message);
$event->option(1515563606); # in Buddy list then 1515563606 else 1515563605
$server->send( $event->to_raw_string, 0 );
}
=head2 $yahoo->change_state($busy, $status_message)
This method sets the I<status messages> for the current user. 'Status message' is set by C<$status_message>. 'Busy icon' is set by the numerical value of C<$busy>.
The C<$busy> should be called with following arguments:
0 - I'm Available
1 - Busy
2 - Sleep
=cut
sub change_state {
my $self = shift;
my $busy = shift;
my $message = join '', @_;
my $server = $self->handle;
my $event = $self->create('ChangeState');
$event->status_code(99); # 99 : Custom status
$event->busy($busy);
$event->body($message);
$server->send( $event->to_raw_string, 0 );
}
lib/Net/YahooMessenger.pm view on Meta::CPAN
my $status_code = shift || 0;
my $server = $self->handle;
my $event = $self->create('ChangeState');
$event->status_code($status_code);
$event->busy(1);
$server->send( $event->to_raw_string, 0 );
}
sub ping {
lib/Net/YahooMessenger.pm view on Meta::CPAN
id => 'yahoo_id',
password => 'password',
);
$yahoo->login or die "Can't login Yahoo!Messenger";;
$yahoo->change_state(IN_BUSY, q{I'm very busy now!});
sleep 5;
__END__
=head2 Received message output to STDOUT
Net-Z3950-AsyncZ
view release on metacpan or search on metacpan
{
my @results=();
my @errors=();
my @recSize = ();
my $busy = 0;
my $utf8_init = 0;
sub is_utf8_init {
$utf8_init;
}
$results[$index]->[$i] = $cs->to_utf8($results[$index]->[$i]);
}
}
sub _saveResults {
$busy = 1;
my ($arr, $index) = @_;
$results[$index] = $arr;
$busy = 0;
}
sub _saveErrors {
@errors = @_;
}
sub _isBusy { return $busy; }
# returns reference to results array
sub getResult {
my ($self,$index) = @_;
_utf8($index) if $self->{options}[$index]-> _getFieldValue('utf8');
sub getMaxErrors { return scalar @errors; }
sub _callback {
$busy = 1;
my ($self, $index) = @_;
_utf8($index) if $self->{options}[$index]-> _getFieldValue('utf8');
my $cb = $self->{options}[$index]-> _getFieldValue('cb');
$cb = $self->{cb} if !$cb;
$size =~ /\*==(\d+)==\*/;
$recSize[$index] = $1 ? $1 : 0;
$results[$index]->[$last_el] =~s/\*==(\d+)==\*//;
&$cb($index, $results[$index]) if $cb;
$busy = 0;
}
}
NetAddr-BridgeID
view release on metacpan or search on metacpan
lib/NetAddr/BridgeID.pm view on Meta::CPAN
=head2 Internet Relay Chat
You can get live help by using IRC ( Internet Relay Chat ). If you don't know what IRC is,
please read this excellent guide: L<http://en.wikipedia.org/wiki/Internet_Relay_Chat>. Please
be courteous and patient when talking to us, as we might be busy or sleeping! You can join
those networks/channels and get help:
=over 4
=item *
NetApp
view release on metacpan or search on metacpan
lib/NetApp/Volume.pm view on Meta::CPAN
croak(__PACKAGE__ . "->delete_all_snapshots not yet implemented\n");
# XXX: This one's tricky to implement. Should we parse the
# output, and attempt to return a list of what was delete, and
# what was busy? Probably too ugly.
my $self = shift;
return $self->get_filer->_run_command(
command => [ qw( snap delete -a -f -q ), $self->get_name ],
NetSDS
view release on metacpan or search on metacpan
lib/NetSDS/EDR.pm view on Meta::CPAN
This methods converts records to JSON and write to file.
Each record writing to one separate string.
Example:
$edr->write({from => '380441234567', to => '5552222', status => 'busy'});
=cut
#-----------------------------------------------------------------------
sub write {
NetServer-Generic
view release on metacpan or search on metacpan
$SIG{CHLD} = \&reap_child;
my @buffer = ();
my $buffer = "";
$NetServer::Debug && print STDERR "$n: About to loop on scoreboard file\n";
my $loopcnt = 0;
my $busycnt = 0;
my @busyvec = ();
#while(@buffer = $self->_read_fifo()) {
*READ_PIPE = $self->read_pipe();
while($buffer = <READ_PIPE>) {
$NetServer::Debug
&& print STDERR "busyvec: [", join("][", @busyvec), "]\n";
$loopcnt++;
$NetServer::Debug
&& print STDERR "$n: in pipe read loop $loopcnt\n";
$buffer =~ tr/ //;
chomp $buffer;
$NetServer::Debug
&& print STDERR "$n: buffer: $buffer\n";
my ($child_pid, $status) = split(/:/, $buffer);
# kids write $$:busy or $$:idle into the pipe whenever
# they change state.
if ($status eq "exit") {
# a child just exited on us
$NetServer::Debug
&& print STDERR "$n: child $child_pid just died\n";
delete($scoreboard->{$child_pid});
} elsif ($status eq "busy") {
$scoreboard->{$child_pid} = "busy";
push(@busyvec, $child_pid);
$busycnt++;
} elsif ($status eq "idle") {
$scoreboard->{$child_pid} = "idle";
@busyvec = grep(!/$child_pid/, @busyvec);
$busycnt--;
} elsif ($status eq "start") {
$scoreboard->{$child_pid} = "idle";
}
$NetServer::Debug && print STDERR "$n: $child_pid has status [",
$scoreboard->{$child_pid}, "]\n",
"$n: got ", scalar(@busyvec), " busy kids\n";
$busycnt = scalar(@busyvec);
my $all_kids = scalar keys %$scoreboard;
$NetServer::Debug &&
print STDERR "$n: $busycnt children busy of $all_kids total\n";
# busy_kids is number of kids currently busy; all_kids is number of kids
if ((($all_kids - $busycnt) < $spare_servers) and
($all_kids <= $max_servers)) {
my $kids_to_launch = ($spare_servers - ($all_kids - $busycnt)) +1;
$NetServer::Debug &&
print STDERR "spare servers: $spare_servers, ",
"all kids: $all_kids, ",
"busycnt: $busycnt\n",
"kids to launch = spares - (all - busy) +1 ",
" => $kids_to_launch\n";
# launch new children
for (my ($i) = 0; $i < $kids_to_launch; $i++) {
my $pid = fork();
sub _do_preforked_child {
my $self = shift;
# we are a preforked child process. We have an IO::Pipe called
# $self->writer() that we write strange things to. Each "strange thing"
# consists of a line containing our PID, a colon, and one of three strings:
# busy, idle, or exit. We run like a run_select server, except that we
# write a busy line whenever we accept a connection, an idle line whenever
# we finish handling a connection, and an exit line when our age exceeds
# $self->server_lifespan() and we suicide.
#
my $n = "_do_preforked_child($$)"; # for reporting status
my $server_lifespan = ( $self->server_lifespan() or 1000 );
}
} else {
if (! eof($sock)) {
$my_age++;
$NetServer::Debug
&& print STDERR "$n: print WRITE_PIPE ($$:busy)\n";
print WRITE_PIPE "$$:busy\n";
$NetServer::Debug
&& print STDERR "$n: serving connection\n";
$sock->autoflush(1);
my ($in_port, $in_addr) = sockaddr_in($sock->sockname());
$self->servername([$in_port, $in_addr]);
NetServer-Portal
view release on metacpan or search on metacpan
lib/NetServer/Portal/Top.pm view on Meta::CPAN
$s .= $tm."\n";
my @load;
my @events = all_watchers();
for my $sec (15,60,60*15) {
my $busy = 0;
for (@events) { $busy += ($_->stats($sec))[2] }
my $idle = (idle_time($sec))[2];
my $tm = $idle + $busy;
push @load, $tm? $busy / $tm : 0;
}
my @all = map {
[{ obj => $_,
id => assign_id($_),
NexposeSimpleXML-Parser
view release on metacpan or search on metacpan
t/test1.xml view on Meta::CPAN
/doc/libmysqlclient15off/
</key>
</vulnerability>
<vulnerability id="http-generic-browsable-dir" resultCode="VE">
<key>
/doc/busybox-initramfs/
</key>
</vulnerability>
<vulnerability id="http-generic-browsable-dir" resultCode="VE">
<key>
/doc/gstreamer0.10-plugins-base/
Nginx-Perl
view release on metacpan or search on metacpan
*) Feature: the ngx_http_fastcgi_module and the directives:
fastcgi_pass, fastcgi_root, fastcgi_index, fastcgi_params,
fastcgi_connect_timeout, fastcgi_send_timeout, fastcgi_read_timeout,
fastcgi_send_lowat, fastcgi_header_buffer_size, fastcgi_buffers,
fastcgi_busy_buffers_size, fastcgi_temp_path,
fastcgi_max_temp_file_size, fastcgi_temp_file_write_size,
fastcgi_next_upstream, and fastcgi_x_powered_by.
*) Bugfix: the "[alert] zero size buf" error; the bug had appeared in
0.1.3.
Nile
view release on metacpan or search on metacpan
lib/Nile.pm view on Meta::CPAN
# CLI
return 1;
#if (-t STDIN) { }
#use IO::Interactive qw(is_interactive interactive busy);if ( is_interactive() ) {print "Running interactively\n";}
}
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
=head2 error()
$app->error("error message");
OCBNET-WebSprite
view release on metacpan or search on metacpan
t/fam/sprites/sport_shuttlecock.png
t/fam/sprites/sport_soccer.png
t/fam/sprites/sport_tennis.png
t/fam/sprites/star.png
t/fam/sprites/status_away.png
t/fam/sprites/status_busy.png
t/fam/sprites/status_offline.png
t/fam/sprites/status_online.png
t/fam/sprites/stop.png
t/fam/sprites/style.png
t/fam/sprites/style_add.png
OOPS
view release on metacpan or search on metacpan
lib/OOPS/OOPS1001.pm view on Meta::CPAN
our $debug_virtual_ovals = 0; # original values of virtual has
our $debug_hashscalar = 0; # scalar(%tied_hash)
our $debug_object_id = 0; # details of id allocation
our $debug_getobid_context = 0; # stack trace for new objects
our $debug_dbidelay = 0; # add small delay before chaning transaction mode
our $debug_tdelay = 150000; # loop size for busy wait
our $debug_dbi = 0; # DBI debug level: 0 or 1 or 2
# debug set for ref.t
$debug_27555 = $debug_write_ref = $debug_load_object = $debug_load_values = $debug_memory = $debug_commit = $debug_refalias = $debug_write_ref = 1 if 0;
OS2-Proc
view release on metacpan or search on metacpan
priority_class - Idle-Time/Regular/Time-Critical/Fixed-High
priority_level - Priority shift inside class (larger is higher)
sleepid - ???
slotid - "Global" thread id
state - 1,2,5 (see thread_state)
systime - Cumulative no. of busy ticks spent in syscalls
thread_state - Ready/Blocked/Running
threadid - Thread Id "in the process"
usertime - Cumulative no. of busy ticks spent in user code
Keep in mind that the semantic of priority_class is not monotonic,
monotonic is C<Idle-Time/Regular/Fixed-High/Time-Critical>.
The $href_modules is the same as for mod_info().
OS2-UPM
view release on metacpan or search on metacpan
RETVAL = "The local logon succeeded. The users"
" password is expired.";
break;
case UPM_SS_BUSY:
RETVAL = "The local logon failed. The Local"
" security was busy.";
break;
case UPM_SS_DEAD:
RETVAL = "The local logon failed. Local"
" security has terminated unexpectedly.";
break;
Object-Anon
view release on metacpan or search on metacpan
lib/Object/Anon.pm view on Meta::CPAN
=over 4
=item *
Class caching. It'd be nice for the same return in a busy function to be able
to reuse the class that was generated last time. The only difficulty is
determining when to do this. L<Net::Twitter> does this with data returned from
the Twitter API by taking a SHA1 of the returned keys and uses that as a cache
key for a Moose metaclass. That's a nice approach when you know the incoming
hash is always JSON, but doesn't work as well when you can't predict the value
Object-Remote
view release on metacpan or search on metacpan
lib/Object/Remote.pm view on Meta::CPAN
=item Run loop favors certain filehandles/connections
=item High levels of load can starve timers of execution opportunities
These are issues that only become a problem at large scales. The end result of these two
issues is quite similiar: some remote objects may block while the local run loop is either busy
servicing a different connection or is not executing because control has not yet been returned to
it. For the same reasons timers may not get an opportunity to execute in a timely way.
Internally Object::Remote uses timers managed by the run loop for control tasks. Under
high load the timers can be preempted by servicing I/O on the filehandles and execution
ObjectDBI
view release on metacpan or search on metacpan
lib/ObjectDBI.pm view on Meta::CPAN
'sequence' => Sequence name for easily retrieving new IDs.
'sequencesql' => Sequence SQL for retrieving a new ID.
'sequencefnc' => A function ref to be used to retrieve a new ID.
'overwrite' => Overwrite objects of the same type and name.
'chunksize' => A number defining at what length values will get split.
'debug' => Setting it at anything will make STDERR a busy stream.
About sequences: the first available method given will be used. So please
do yourself a favour, avoid confusion, and use only one of the available
methods out of 'sequence', 'sequencesql' and 'sequencefnc'.
OpenCL
view release on metacpan or search on metacpan
$e->cb (sub { $flag = 1 });
1 until $flag;
# $flag is now 1
The reason why you shouldn't blindly copy the above code is that
busy waiting is a really really bad thing, and really really bad for
performance.
While at first this asynchronous business might look exciting, it can be
really hard, because you need to be prepared for the callback code to be
executed at any time, which limits the amount of things the callback code
OpenGuides
view release on metacpan or search on metacpan
t/608_bug_website_displayed.t view on Meta::CPAN
$guide->wiki->write_node( "South Croydon Station$postfix",
"A sleepy main-line station in what is arguably the nicest part of Croydon.",
undef, { website => "$prefix://example.com/" } )
or die "Couldn't write node";
$guide->wiki->write_node( "North Croydon Station$postfix",
"A busy main-line station in what is arguably the furthest North part of "
. "Croydon.", undef, { website => "$prefix://longer.example.com/asdfasdf" } )
or die "Couldn't write node";
$guide->wiki->write_node( "East Croydon Station$postfix",
"A busy main-line station that actually exists.", undef,
{ website => "$prefix://www.example.com/foo" } )
or die "Couldn't write node";
$guide->wiki->write_node( "West Croydon Station$postfix",
"Another main-line station that actually exists.", undef,
{ website => "$prefix://www.example.com/bar/" } )
OpenInteract
view release on metacpan or search on metacpan
conf/sample-httpd_static.conf view on Meta::CPAN
RewriteRule ^/robots\.txt - [L]
# Discard (with a '403 Forbidden') requests for the Code Red document
# (hole in IIS servers that can keep your backend mod_perl servers
# busy...)
RewriteRule ^/default\.ida - [F]
# Proxy ([P]) all other requests to a back-end server
OpenMP-Environment
view release on metacpan or search on metacpan
lib/OpenMP/Environment.pm view on Meta::CPAN
=item C<GOMP_STACKSIZE>
Determines how long a threads waits actively with consuming CPU
power before waiting passively without consuming CPU power. The
value may be either INFINITE, INFINITY to always wait actively or
an integer which gives the number of spins of the busy-wait loop.
The integer may optionally be followed by the following suffixes
acting as multiplication factors: k (kilo, thousand), M (mega,
million), G (giga, billion), or T (tera, trillion). If undefined,
0 is used when OMP_WAIT_POLICY is PASSIVE, 300,000 is used when
OMP_WAIT_POLICY is undefined and 30 billion is used when
OpenPlugin
view release on metacpan or search on metacpan
AUTHORS
Eric Andreychek <eric@openthought.net>
Thanks to Chris Winters for helping this project get started. Although he's
quite busy these days, this project wouldn't be where it is today if it weren't
for his efforts early on.
( run in 0.611 second using v1.01-cache-2.11-cpan-87723dcf8b7 )