view release on metacpan or search on metacpan
examples/benchmarks.pl view on Meta::CPAN
'HTML::Tiny', => sub{ Bench::HTML::Tiny::modal 'this is my modal' },
'HTML::HTML5::Builder' => sub{ Bench::HTML::HTML5::Builder::modal 'this is my modal' },
'HTML::Untidy' => sub{ Bench::HTML::Untidy::modal 'this is my modal' },
};
Benchmark: timing 10000 iterations of HTML::Builder, HTML::HTML5::Builder, HTML::Tiny, HTML::Untidy...
HTML::Builder: 66 wallclock secs (33.58 usr + 31.68 sys = 65.26 CPU) @ 153.23/s (n=10000)
HTML::HTML5::Builder: 5 wallclock secs ( 5.30 usr + 0.00 sys = 5.30 CPU) @ 1886.79/s (n=10000)
HTML::Tiny: 2 wallclock secs ( 1.38 usr + 0.00 sys = 1.38 CPU) @ 7246.38/s (n=10000)
HTML::Untidy: 1 wallclock secs ( 0.88 usr + 0.00 sys = 0.88 CPU) @ 11363.64/s (n=10000)
view release on metacpan or search on metacpan
lib/HTML/Zoom/FilterBuilder.pm view on Meta::CPAN
For a given selection, repeat over transformations, typically for the purposes
of populating lists. Takes either an array of anonymous subroutines or a zoom-
able object consisting of transformation.
Example of array reference style (when it doesn't matter that all iterations are
pre-generated)
$zoom->select('table')->repeat([
map {
my $elem = $_;
lib/HTML/Zoom/FilterBuilder.pm view on Meta::CPAN
=item repeat_between [SELECTOR]
Selects object to be repeated between items. In the case of array this object
is put between elements, in case of iterator it is put between results of
subsequent iterations, in the case of streamable it is put between events
(->to_stream->next).
See documentation for L</repeat_content>
=back
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
view release on metacpan or search on metacpan
lib/HTTP/Cookies/Chrome.pm view on Meta::CPAN
my $key = do {
state $rc2 = require PBKDF2::Tiny;
my $s = $self->_platform_settings;
my $salt = 'saltysalt';
my $length = 16;
PBKDF2::Tiny::derive( 'SHA-1', $password, $salt, $s->{iterations}, $length );
};
state $rc1 = require Crypt::Rijndael;
my $cipher = Crypt::Rijndael->new( $key, Crypt::Rijndael::MODE_CBC() );
$cipher->set_iv( ' ' x 16 );
lib/HTTP/Cookies/Chrome.pm view on Meta::CPAN
sub _platform_settings {
# https://n8henrie.com/2014/05/decrypt-chrome-cookies-with-python/
# https://github.com/n8henrie/pycookiecheat/issues/12
state $settings = {
darwin => {
iterations => 1003,
},
linux => {
iterations => 1,
},
MSWin32 => {
},
};
view release on metacpan or search on metacpan
lib/HTTP/Cookies/ChromeMacOS.pm view on Meta::CPAN
my $salt = 'saltysalt';
my $iv = ' ' x 16;
my $salt_len = 16;
my $pass = _get_pass();
my $iterations = 1003;
my $key = derive( 'SHA-1', $pass, $salt, $iterations, $salt_len );
my $cipher = Crypt::CBC->new(
-cipher => 'Crypt::OpenSSL::AES',
-key => $key,
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
view release on metacpan or search on metacpan
about 4 times less code than either LWP::UserAgent, or HTTP::Lite), it
is also in my tests significantly faster. Here are my benchmark
results requesting http://localhost/ (the Apache "Successful Install"
page):
Benchmark: timing 1000 iterations of ghttp, lite, lwp...
ghttp: 8 wallclock secs ( 0.96 usr + 1.16 sys = 2.12 CPU)
lite: 21 wallclock secs ( 3.00 usr + 3.44 sys = 6.44 CPU)
lwp: 18 wallclock secs ( 9.76 usr + 1.59 sys = 11.35 CPU)
=cut
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
view release on metacpan or search on metacpan
lib/HTTP/Response/Parser.pm view on Meta::CPAN
=head1 BENCHMARK
Compare with HTTP::Response->parse.
parse small_header
Benchmark: timing 20000 iterations of parse, xs...
parse: 11 wallclock secs ( 5.05 usr + 0.01 sys = 5.06 CPU) @ 3952.57/s (n=20000)
xs: 2 wallclock secs ( 0.63 usr + 0.00 sys = 0.63 CPU) @ 31746.03/s (n=20000)
parse large_header
Benchmark: timing 20000 iterations of parse, xs...
parse: 26 wallclock secs (15.33 usr + 0.10 sys = 15.43 CPU) @ 1296.18/s (n=20000)
xs: 2 wallclock secs ( 1.22 usr + 0.00 sys = 1.22 CPU) @ 16393.44/s (n=20000)
=head1 EXPORTS
view release on metacpan or search on metacpan
tools/bench.pl view on Meta::CPAN
}
sub run_benchmark {
my ($name, $cookie) = @_;
my $iterations = 1e5;
my $bench = Dumbbench->new(
target_rel_precision => 0.005,
initial_runs => 20,
);
$bench->add_instances(
# Dumbbench::Instance::PerlSub->new(
# name => get_name('Cookie::Baker', $name),
# code => sub {
# for(1..$iterations){
# Cookie::Baker::crush_cookie($cookie);
# }
# },
# ),
Dumbbench::Instance::PerlSub->new(
name => get_name('Cookie::Baker::XS', $name),
code => sub {
for(1..$iterations){
Cookie::Baker::XS::crush_cookie($cookie);
}
},
),
Dumbbench::Instance::PerlSub->new(
name => get_name('HTTP::XSCookies', $name),
code => sub {
for(1..$iterations){
HTTP::XSCookies::crush_cookie($cookie);
}
},
),
);
view release on metacpan or search on metacpan
lib/Hailo/Engine/Scored.pm view on Meta::CPAN
after BUILD => sub {
my ($self) = @_;
my %args = $self->arguments;
if (defined $args{iterations} && defined $args{interval}) {
die __PACKAGE__.": You can only specify one of 'iterations' and 'interval'\n";
}
return;
};
sub reply {
lib/Hailo/Engine/Scored.pm view on Meta::CPAN
} keys %$token_cache;
}
my $token_probs = $self->_get_pivot_probabilites(\@token_counts);
my @started = gettimeofday();
my $iterations = 0;
my $done;
my %args = $self->arguments;
if (!defined $args{iterations} && !defined $args{interval}) {
# construct replies for half a second by default
$args{interval} = 0.5;
}
if (defined $args{iterations}) {
$done = sub {
return 1 if $iterations == $args{iterations};
};
}
else {
$done = sub {
my $elapsed = tv_interval(\@started, [gettimeofday]);
lib/Hailo/Engine/Scored.pm view on Meta::CPAN
};
}
my (%link_cache, %expr_cache, $best_score, $best_reply);
while (1) {
$iterations++;
my $reply = $self->_generate_reply($token_probs, \%expr_cache);
return if !defined $reply; # we don't know any expressions yet
my $score = $self->_evaluate_reply(\@input_token_ids, $reply, \%link_cache);
lib/Hailo/Engine/Scored.pm view on Meta::CPAN
=head2 C<engine_args>
This is a hash reference which can have the following keys:
=head3 C<iterations>
The number of replies to generate before returning the best one.
=head3 C<interval>
The time (in seconds) to spend on generating replies before returning the
best one.
You can not specify both C<iterations> and C<interval> at the same time. If
neither is specified, a default C<interval> of 0.5 seconds will be used.
=head1 AUTHORS
Hinrik E<Ouml>rn SigurE<eth>sson, hinrik.sig@gmail.com
view release on metacpan or search on metacpan
PortScanner.pm view on Meta::CPAN
my ( $databits, $parity, $stopbits, $handshake );
my $setting;
my $device;
my $config = $serial->{SEARCH_PARM} = {};
my $parm_found;
my $read_iterations;
my $iterations;
my $chars = 0;
my ( $bytes_read, $data_read );
my $waited;
$serial->_add_scan_log("Scan Ports Request");
PortScanner.pm view on Meta::CPAN
SETTING => "8N1"
}
);
}
# Figure the number of read iterations is needed
if ( exists( $config->{MAX_WAIT} ) ) {
$serial->_add_scan_log("(Max Wait set at $config->{MAX_WAIT})");
$read_iterations = int( $config->{MAX_WAIT} / ( $serial->{READ_CONST_TIME} / 1000 ) );
$read_iterations = 1 if ( $read_iterations < 1 );
}
else {
# Must always go though the loop once
$read_iterations = 1;
}
# Begin Scan of Com Ports
PORT:
PortScanner.pm view on Meta::CPAN
# Wait a maximum amount of time to get expected output but move on
# if we dont get it in the alloted amount of time. This also protects
# us from a device just spewing data.
for ( $iterations = 1 ; $iterations <= $read_iterations ; $iterations++ ) {
# Read from the port
( $bytes_read, $data_read ) = $PortObj->read(255); # docs say this must be 255 always
$waited += $serial->{READ_CONST_TIME};
view release on metacpan or search on metacpan
Word/noun.txt view on Meta::CPAN
it,its
italian,italians
italic,italics
itch,itches
item,items
iteration,iterations
itinerant,itinerants
itinerary,itineraries
iud,iuds
ivory,ivories
ivy,ivies
view release on metacpan or search on metacpan
benchmark/hash_bulk_keycopy.pl view on Meta::CPAN
},
}));
__END__
$ perl -Mblib benchmark/hash_bulk_keycopy.pl
Benchmark: timing 1000000 iterations of PP, XS...
PP: 11 wallclock secs (10.54 usr + 0.01 sys = 10.55 CPU) @ 94786.73/s (n=1000000)
XS: 6 wallclock secs ( 5.26 usr + 0.00 sys = 5.26 CPU) @ 190114.07/s (n=1000000)
Rate PP XS
PP 94787/s -- -50%
XS 190114/s 101% --
view release on metacpan or search on metacpan
lib/Hash/Map.pm view on Meta::CPAN
...
);
=head2 method each_source, each_target, source_iterator, target_iterator
This methods allows to work with iterations.
while ( my ($key, $value) = $self->each_source ) {
...
}
view release on metacpan or search on metacpan
my $i = 0;
while (my $mk = each %hmk) {
++$i;
ok(exists $hmk{$mk}, 'each all: scalar context');
}
is(scalar(keys %hmk), $i, 'each all: number of iterations');
foreach (0..$#mk) {
delete $hmk{$mk[$_]};
while (my ($mk, $v) = each %hmk) {
is_deeply($hmk{$mk}, $v, "each $i: @$mk");
view release on metacpan or search on metacpan
lib/Hash/StoredIterator.pm view on Meta::CPAN
=item Modification of hash during iteration
Just like with the builtin C<each()> modifying the hash between calls to each
is not recommended and can result in undefined behavior. The builtin C<each()>
does allow for deleting the iterations key, however that is B<NOT> supported by
this library.
=item sort() edge case
For some reason C<[sort hkeys %hash]> and C<[sort hkeys(%hash)]> both result in
view release on metacpan or search on metacpan
lib/Hessian/Deserializer.pm view on Meta::CPAN
=head2 process_message
Process a complete Hessian message by reading chunk by chunk until reaching
the end of the input filehandle. The deserialized message is currently
returned in an array reference, although this is likely to change in future
iterations. The contents of this array reference depend on the data that is
parsed from the Hessian message.
view release on metacpan or search on metacpan
BCM2835/src/ltmain.sh view on Meta::CPAN
*)
# Relative path, prepend $cwd.
func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
;;
esac
# Cancel out all the simple stuff to save iterations. We also want
# the path to end with a slash for ease of parsing, so make sure
# there is one (and only one) here.
func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
-e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
while :; do
view release on metacpan or search on metacpan
examples/seesaw/interrupt.pl view on Meta::CPAN
( $interrupt_confirmed ) = $self->gpio_get_interrupt_flags( $sppin );
$self->sleep_microseconds( 500 );
}
unless( $counter % 100 ) {
print qq($counter iterations completed successfully\n);
print qq(Press CTRL + C to end\n);
}
}
}
view release on metacpan or search on metacpan
lib/HoneyClient/Agent/Driver/Browser.pm view on Meta::CPAN
'IE' or 'FF', must inherit from this package.
Fundamentally, the Browser driver is initialized with a set of absolute URLs
for the browser to drive to. Upon visiting each URL, the driver collects
any B<new> links found and will attempt to drive the browser to each
valid URL upon subsequent iterations of work.
For each top-level URL given, the driver will attempt to process all
corresponding links that are hosted on the same server, in order to
simulate a complete 'spider' of each server.
lib/HoneyClient/Agent/Driver/Browser.pm view on Meta::CPAN
Returns the current status of the Browser driver B<$object>, as it's state
exists, between subsequent calls to $object->driver().
Specifically, the data returned is a reference to a hashtable,
containing specific statistical information about the status
of the Browser driver's progress, between iterations of driving the
browser process.
The following is an example hashtable, containing all the
(key => value) pairs that would exist in the output.
view release on metacpan or search on metacpan
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
* <li><code>method</code> - {Function} REQUIRED the callback function.</li>
* <li><code>scope</code> - {Object} the scope from which to execute the callback. Default is the global window scope.</li>
* <li><code>argument</code> - {Array} parameters to be passed to method as individual arguments.</li>
* <li><code>timeout</code> - {number} millisecond delay to wait after previous callback completion before executing this callback. Negative values cause immediate blocking execution. Default 0.</li>
* <li><code>until</code> - {Function} boolean function executed before each iteration. Return true to indicate completion and proceed to the next callback.</li>
* <li><code>iterations</code> - {Number} number of times to execute the callback before proceeding to the next callback in the chain. Incompatible with <code>until</code>.</li>
* </ul>
*
* @namespace YAHOO.util
* @class Chain
* @constructor
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
if (c.until) {
for (;!c.until();) {
// Execute the callback from scope, with argument
fn.apply(o,args);
}
} else if (c.iterations) {
for (;c.iterations-- > 0;) {
fn.apply(o,args);
}
} else {
fn.apply(o,args);
}
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
// Shift this callback from the queue and execute the next
// callback
this.q.shift();
return this.run();
}
// Otherwise if either iterations is not set or we're
// executing the last iteration, shift callback from the queue
} else if (!c.iterations || !--c.iterations) {
this.q.shift();
}
// Otherwise set to execute after the configured timeout
this.id = setTimeout(function () {
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
// Set up for the next loop
oArg.nCurrentRecord = i;
}
},
scope: this,
iterations: (loopN > 0) ? Math.ceil(nRecordsLength/loopN) : 1,
argument: {
nCurrentRecord: 0,//nRecordsLength-1, // Start at first Record
nLoopLength: (loopN > 0) ? loopN : nRecordsLength
},
timeout: (loopN > 0) ? 0 : -1
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
// Set up for the next loop
oArg.nCurrent = i;
}
},
scope: this,
iterations: (loopN > 0) ? Math.ceil(nTotal/loopN) : 1,
argument: {
nCurrent: nTotal,
nLoopLength: (loopN > 0) ? loopN : nTotal
},
timeout: (loopN > 0) ? 0 : -1
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
}
}
oArg.nCurrentRow = i;
}
},
iterations: (loopN > 0) ? Math.ceil(loopEnd/loopN) : 1,
argument: {nCurrentRow:0, aIndexes:aKeyIndexes},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._runRenderChain();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
}
}
oArg.nCurrentRow = i;
}
},
iterations: (loopN > 0) ? Math.ceil(loopEnd/loopN) : 1,
argument: {nCurrentRow:0,aTdTemplates:aTdTemplates,descKeyIndexes:descKeyIndexes},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._runRenderChain();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
}
}
oArg.nCurrentRow = i;
}
},
iterations: (loopN > 0) ? Math.ceil(loopEnd/loopN) : 1,
argument: {nCurrentRow:0, aIndexes:aOrigKeyIndexes},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._runRenderChain();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
Dom.addClass(allRows[oArg.rowIndex].cells[oArg.cellIndex],DT.CLASS_SELECTED);
}
oArg.rowIndex++;
},
scope: this,
iterations: allRows.length,
argument: {rowIndex:0,cellIndex:oColumn.getKeyIndex()}
});
this._clearTrTemplateEl();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
Dom.removeClass(allRows[oArg.rowIndex].cells[oArg.cellIndex],DT.CLASS_SELECTED);
}
oArg.rowIndex++;
},
scope: this,
iterations:allRows.length,
argument: {rowIndex:0,cellIndex:oColumn.getKeyIndex()}
});
this._clearTrTemplateEl();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
Dom.addClass(allRows[oArg.rowIndex].cells[oArg.cellIndex],DT.CLASS_HIGHLIGHTED);
}
oArg.rowIndex++;
},
scope: this,
iterations:allRows.length,
argument: {rowIndex:0,cellIndex:oColumn.getKeyIndex()},
timeout: -1
});
this._elTbody.style.display = "none";
this._runRenderChain();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
Dom.removeClass(allRows[oArg.rowIndex].cells[oArg.cellIndex],DT.CLASS_HIGHLIGHTED);
}
oArg.rowIndex++;
},
scope: this,
iterations:allRows.length,
argument: {rowIndex:0,cellIndex:oColumn.getKeyIndex()},
timeout: -1
});
this._elTbody.style.display = "none";
this._runRenderChain();
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
this._elTbody.insertBefore(df, elNext);
oArg.nCurrentRow = i;
oArg.nCurrentRecord = j;
}
},
iterations: (loopN > 0) ? Math.ceil(loopEnd/loopN) : 1,
argument: {nCurrentRow:recIndex,nCurrentRecord:0,aRecords:aRecords},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._oChainRender.add({
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
}
oArg.nCurrentRow = i;
oArg.nDataPointer = j;
}
},
iterations: (loopN > 0) ? Math.ceil(rowCount/loopN) : 1,
argument: {nCurrentRow:startIndex,aRecords:aNewRecords,nDataPointer:0,isAdding:isAdding},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._oChainRender.add({
share/root/static/yui/build/datatable/datatable-debug.js view on Meta::CPAN
this._deleteTrEl(i);
}
oArg.nCurrentRow = i;
}
},
iterations: (loopN > 0) ? Math.ceil(count/loopN) : 1,
argument: {nCurrentRow:highIndex},
scope: this,
timeout: (loopN > 0) ? 0 : -1
});
this._oChainRender.add({
view release on metacpan or search on metacpan
lib/Hopkins/Plugin/RPC.pm view on Meta::CPAN
$res->content({ success => 1 });
$kernel->post('rpc.soap' => DONE => $res);
} else {
# if the session wasn't found, we'll try to wait a
# bit for it to show up. if we exceed the maximum
# number of wait iterations, we'll return an error
# to the client.
if ($iter > HOPKINS_RPC_QUEUE_STATUS_WAIT_ITER_MAX) {
# exceeded maximum wait iterations; return an
# error to the client.
$res->content({ success => 0, err => "unable to start queue $name" });
$kernel->post('rpc.soap' => DONE => $res);
} else {
lib/Hopkins/Plugin/RPC.pm view on Meta::CPAN
$res->content({ success => 1 });
$kernel->post('rpc.soap' => DONE => $res);
} else {
# if the session was found, we'll try to wait a bit
# for it to be stopped. if we exceed the maximum
# number of wait iterations, we'll return an error
# to the client.
if ($iter > HOPKINS_RPC_QUEUE_STATUS_WAIT_ITER_MAX) {
# exceeded maximum wait iterations; return an
# error to the client.
$res->content({ success => 0, err => "unable to stop $name" });
$kernel->post('rpc.soap' => DONE => $res);
} else {
view release on metacpan or search on metacpan
bench/future-benchmark.pl view on Meta::CPAN
->finally(sub { });
$f->done(21);
}
my $elapsed = time() - $start;
my $rate = $chain_iter / $elapsed;
printf "Hypersonic::Future: %.0f/s (%d iterations in %.2f seconds)\n", $rate, $chain_iter, $elapsed;
print "\n";
# ============================================================================
# Summary
# ============================================================================
view release on metacpan or search on metacpan
t/MyTestHelpers.pm view on Meta::CPAN
# uncomment this to run the ### lines
#use Smart::Comments;
@ISA = ('Exporter');
@EXPORT_OK = qw(findrefs
main_iterations
warn_suppress_gtk_icon
glib_gtk_versions
any_signal_connections
nowarnings);
%EXPORT_TAGS = (all => \@EXPORT_OK);
t/MyTestHelpers.pm view on Meta::CPAN
#-----------------------------------------------------------------------------
# Gtk/Glib helpers
# Gtk 2.16 can go into a hard loop on events_pending() / main_iteration_do()
# if dbus is not running, or something like that. In any case limiting the
# iterations is good for test safety.
#
sub main_iterations {
my $count = 0;
if (DEBUG) { MyTestHelpers::diag ("main_iterations() ..."); }
while (Gtk2->events_pending) {
$count++;
Gtk2->main_iteration_do (0);
if ($count >= 500) {
MyTestHelpers::diag ("main_iterations(): oops, bailed out after $count events/iterations");
return;
}
}
MyTestHelpers::diag ("main_iterations(): ran $count events/iterations");
}
# warn_suppress_gtk_icon() is a $SIG{__WARN__} handler which suppresses spam
# from Gtk trying to make you buy the hi-colour icon theme. Eg,
#
t/MyTestHelpers.pm view on Meta::CPAN
while (! $done) {
if (DEBUG >= 2) { MyTestHelpers::diag ("wait_for_event() iteration $count"); }
Gtk2->main_iteration;
$count++;
}
MyTestHelpers::diag ("wait_for_event(): '$signame' ran $count events/iterations\n");
$widget->signal_handler_disconnect ($sig_id);
Glib::Source->remove ($timer_id);
}
view release on metacpan or search on metacpan
2017-06-17
- modified 'press_curve_3_example.plx' by adding 'select_samples' function, and some typical selections.
- modified '_revs' and '_rev' functions of 'bern.pm', to set x-value to a random number when the slope is zero, or the x-value is out of range. added counter to quit loop after 100 iterations (v0.32).
- fixed problem in 'device_link_1_example.plx', where the output curves were incorrect for v4 dest profiles.
2017-06-18
view release on metacpan or search on metacpan
bin/bro-perl view on Meta::CPAN
}
}
if( $VERBOSE ) {
my $elapsed = tv_interval ( $t0 );
say "Ran $REPEAT iterations in a total of $elapsed seconds";
say sprintf(
"Brotli %s speed: %.6f MB/s",
( $DECOMPRESS ? "decompression" : "compression" ),
$total_size / 1024 / 1024 / $elapsed
);
view release on metacpan or search on metacpan
lib/IO/K8s/Api/Core/V1/ResourceHealth.pm view on Meta::CPAN
package IO::K8s::Api::Core::V1::ResourceHealth;
# ABSTRACT: ResourceHealth represents the health of a resource. It has the latest device health information. This is a part of KEP https://kep.k8s.io/4680 and historical health changes are planned to be added in future iterations of a KEP.
our $VERSION = '1.106';
use IO::K8s::Resource;
k8s health => Str;
lib/IO/K8s/Api/Core/V1/ResourceHealth.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
IO::K8s::Api::Core::V1::ResourceHealth - ResourceHealth represents the health of a resource. It has the latest device health information. This is a part of KEP https://kep.k8s.io/4680 and historical health changes are planned to be added in future it...
=head1 VERSION
version 1.106
view release on metacpan or search on metacpan
lib/IO/ReadPreProcess.pm view on Meta::CPAN
1
}
# $direct is while/until/for
# $arg is loop condition/rest-of-line
# May start: -innn to specify max iterations
# **** THINKS ****
# Loops are found in 2 ways:
# (1) Reading from a {Fd} - ie in getline()
# (2) When in a sub or an enclosing loop
# We always buffer a loop, so the only difference is where/how it is found
lib/IO/ReadPreProcess.pm view on Meta::CPAN
$doneDone = 0;
# Beware: might be here twice
unless($frame->{CondReRun}) {
# Trap run away loops:
return $self->SetError("Maximum iterations ($frame->{LoopMax}) exceeded at $frame->{FrameStart}", 1)
if($frame->{LoopMax} && ++$frame->{LoopCnt} > $frame->{LoopMax});
# evaluation loop expression (not on first time)
$self->{Math}->EvalToScalar($replay->{For3}) if(exists $replay->{For3} and $frame->{LoopCnt} != 1);
}
lib/IO/ReadPreProcess.pm view on Meta::CPAN
Pipes are only allowed with C<.include> if the property C<PipeOK> is true (default false).
=item MaxLoopCount
Loops (C<while>, C<until> and C<for>) will abort after this number of iterations.
The count restarts if the loop is restarted.
A value of C<0> disables this test.
This may be overridden on an individual loop with the C<-i> option.
lib/IO/ReadPreProcess.pm view on Meta::CPAN
CpMove If true: on frame close, any CodeLine to be copied to parent frame.
ReturnFrom If true a .return will unwind to here and return to the previous.
Other properties for loops
LoopMax Max iterations - 0 == no limit - this is copied from code->{LoopMax}
This is also used to identiy the frame as a loop frame
LoopCnt Count of iterations so far
Loop Just to note that it is a loop frame
CondReRun Rerun the condition in main loop, as: .if .subroutine/.directive
intDir Running an internal directive, eg: .if .read var