view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-bar
-boc
-ci=4
-i=4

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

--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/Colouring/In/XS.pm  view on Meta::CPAN

		}
	});

...

	Benchmark: timing 1000000 iterations of Colouring::In, XS...
	Colouring::In: 13 wallclock secs (12.36 usr +  0.00 sys = 12.36 CPU) @ 80906.15/s (n=1000000)
		XS:  0 wallclock secs ( 0.59 usr +  0.01 sys =  0.60 CPU) @ 1666666.67/s (n=1000000)

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/Command/Run.pm  view on Meta::CPAN

cumulative performance degradation in Perl's PerlIO subsystem.  This
affects B<all> PerlIO operations in the process, not just the ones
using the encoding layer.

In benchmarks, nofork with C<:encoding(utf8)> is actually B<slower>
than fork after many iterations, due to this leak.  Raw mode avoids
the issue entirely.

    # Benchmark: code ref with stdin (100-byte input, 1000 iterations)
    fork:                  399/s (baseline)
    nofork + :encoding:    316/s (0.8x — slower than fork!)
    nofork + :utf8 (raw): 13,433/s (34x faster)

=head2 Zero-Modification Callee Integration

 view release on metacpan or  search on metacpan

7zip/DOC/lzma.txt  view on Meta::CPAN

     instructions per second). Rating value is calculated from 
     measured speed and it is normalized with Intel's Core 2 results.
     Also Benchmark checks possible hardware errors (RAM 
     errors in most cases). Benchmark uses these settings:
     (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter. 
     Also you can change the number of iterations. Example for 30 iterations:
       LZMA b 30
     Default number of iterations is 10.

<Switches>
  

  -a{N}:  set compression mode 0 = fast, 1 = normal

 view release on metacpan or  search on metacpan

ex/benchmark.pl  view on Meta::CPAN

use Compress::LZF    ();
use Compress::Snappy ();
use Compress::Zlib   ();

my %opts = (
    iterations => -1,
    size       => 10,  # kB
);
GetOptions(\%opts, 'iterations|i=i', 'size|s=f',);

my $data = join '', ('A'..'Z', 'a'..'z', 0..9, qw(_ .)) x (16 * $opts{size});

my %compress = (
    'Compress::Bzip2::compress'  => sub { Compress::Bzip2::compress($data) },

 view release on metacpan or  search on metacpan

ex/benchmark.pl  view on Meta::CPAN

use Compress::LZF    ();
use Compress::Snappy ();
use Compress::Zlib   ();

my %opts = (
    iterations => -1,
    size       => 10,  # kB
);
GetOptions(\%opts, 'iterations|i=i', 'size|s=f',);

my $data = join '', ('A'..'Z', 'a'..'z', 0..9, qw(_ .)) x (16 * $opts{size});

my %compress = (
    'Compress::Bzip2::compress'  => sub { Compress::Bzip2::compress($data) },

 view release on metacpan or  search on metacpan

ext/zstd/CONTRIBUTING.md  view on Meta::CPAN

    increase your sample count. These should get smaller and smaller. Eventually hopefully
    smaller than the performance win you are expecting.
    * Most processors will take some time to get `hot` when running anything. The observations
    you collect during that time period will very different from the true performance number. Having
    a very large number of sample will help alleviate this problem slightly but you can also
    address is directly by simply not including the first `n` iterations of your benchmark in
    your aggregations. You can determine `n` by simply looking at the results from each iteration
    and then hand picking a good threshold after which the variance in results seems to stabilize.
2. You cannot really get reliable benchmarks if your host machine is simultaneously running
another cpu/memory-intensive application in the background. If you are running benchmarks on your
personal laptop for instance, you should close all applications (including your code editor and

 view release on metacpan or  search on metacpan

lib/Compress/Zopfli.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use Compress::Zopfli;
    $gz = compress($input, ZOPFLI_FORMAT_GZIP, {
        iterations => 15,
        blocksplitting => 1,
        blocksplittingmax => 15,
    });

=head1 DESCRIPTION

lib/Compress/Zopfli.pm  view on Meta::CPAN

Options map directly to the I<zopfli> low-level function. Must be a hash
reference (i.e. anonymous hash) and supports the following options:

=over 5

=item B<iterations>

Maximum amount of times to rerun forward and backward pass to optimize LZ77
compression cost. Good values: 10, 15 for small files, 5 for files over
several MB in size or it will be too slow. Default: 15

lib/Compress/Zopfli.pm  view on Meta::CPAN

- I<Compress::Zopfli::Deflate>

They export one B<compress> function without the I<ZOPFLI_FORMAT> option.

    use Compress::Zopfli::Deflate;
    compress $input, { iterations: 20 };

=head1 CONSTANTS

All the I<zopfli> constants are automatically imported when you make use
of I<Compress::Zopfli>. See L</DESCRIPTION> for a complete list.

 view release on metacpan or  search on metacpan

ext/zstd/lib/compress/zstd_ldm.c  view on Meta::CPAN

        /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */
        newLeftoverSize = ZSTD_ldm_generateSequences_internal(
            ldmState, sequences, params, chunkStart, chunkSize);
        if (ZSTD_isError(newLeftoverSize))
            return newLeftoverSize;
        /* 4. We add the leftover literals from previous iterations to the first
         *    newly generated sequence, or add the `newLeftoverSize` if none are
         *    generated.
         */
        /* Prepend the leftover literals from the last call */
        if (prevSize < sequences->size) {

 view release on metacpan or  search on metacpan

t/mutant_killers.t  view on Meta::CPAN

	my $cfg = Config::Abstraction->new(
		config_dirs => [$dir1, $dir2],
	);
	ok(defined($cfg),                  'object created with multiple dirs');
	# Both dirs loaded; script_name consistent across both iterations
	is($cfg->get('dir1key'), 'dir1val', 'dir1 loaded correctly');
	is($cfg->get('dir2key'), 'dir2val', 'dir2 loaded correctly');
	ok(defined($cfg->{script_name}),   'script_name was set');
};

 view release on metacpan or  search on metacpan

t/03leak.t  view on Meta::CPAN

use Test::More qw(no_plan);

# run this with the call to weaken() in ApacheFormat.pm commented out
# and watch the amazing leaking code in top!  You might need to add
# more iterations if it's buzzing by too fast.
for(0 .. 100) {
    my $config = Config::ApacheFormat->new();
    $config->read("t/block.conf");
    ok(1);
}

 view release on metacpan or  search on metacpan

lib/Config/YAMLMacros.pm  view on Meta::CPAN

our @ISA = qw(Exporter);
our @EXPORT = qw(get_config);
our @EXPORT_OK = (@EXPORT, qw(listify replace));

my $max_replace_iterations = 10;

sub listify(\%@)
{
	my ($href, @keys) = @_;
	for my $k (@keys) {

lib/Config/YAMLMacros.pm  view on Meta::CPAN

		# print STDERR "# replacing '$_[0]' with '$href->{$_[0]}'\n";
		return $href->{$_[0]};
	};
	for (;;) {
		$$sref =~ s/($re)/$replace->($1)/ge or last;
		if ($iteration++ >= $max_replace_iterations) {
			confess "too many replacements in $$sref";
		}
	}
}

 view release on metacpan or  search on metacpan

libucl-0.8.1/doc/api.md  view on Meta::CPAN

If parsing operations fail then the resulting UCL object will be a `UCL_STRING`. A caller should always check the type of the returned object and release it after using.

# Iteration functions

Iteration are used to iterate over UCL compound types: arrays and objects. Moreover, iterations could be performed over the keys with multiple values (implicit arrays).
There are two types of iterators API: old and unsafe one via `ucl_iterate_object` and the proposed interface of safe iterators.


## ucl_iterate_object
~~~C

 view release on metacpan or  search on metacpan

lib/ConstantCalculus/CircleConstant.pm  view on Meta::CPAN

If terms and precision is not given, both are estimated from the given number of
places. This will result in a value of Pi, which is accurate to the requested 
places. If places, terms and/or precision is given, the behaviour of the algorithm
can be studied with respect to terms and/or precision.  

The number of iterations is calculated using the knowledge, that each iteration
should result in e.g. 14 new digits after the decimal point. So the value for the 
calculation of the number of terms is set to e.g. 14.  To make sure that reverse as
less as possible digits are changed, the number of terms to calculated is uneven.
So the sign of the term to add is negative after the decimal point.

lib/ConstantCalculus/CircleConstant.pm  view on Meta::CPAN

is exponentiated by e (exponent) and divided by a positive integer m
(modulus).

=head3 estimate_terms()

Estimates the terms or iterations to get the correct number of place.

=head3 truncate_places()

Truncate the number of places to a given value.

 view release on metacpan or  search on metacpan

lib/Container/Buildah.pm  view on Meta::CPAN

	# process scalar value
	my $output;
	$cb->{template}->process(\$value, $cb->{config}, \$output);
	$cb->debug({level => 4}, "expand: $value -> $output");

	# expand templates as long as any remain, up to 10 iterations
	my $count=0;
	while ($output =~ / \[% .* %\] /x and $count++ < 10) {
		$value = $output;
		$output = ""; # clear because template concatenates to it
		$cb->{template}->process(\$value, $cb->{config}, \$output);

 view release on metacpan or  search on metacpan

lib/ControlBreak.pm  view on Meta::CPAN

our $VERSION = 'v0.22.244';

use Carp            qw(croak);

# public attributes
field $iteration    :reader     { 0 };  # [0] counts iterations
field @level_names  :reader;            # [1] list of level names

# private attributes
field $_num_levels;                     # [2] the number of control levels
field %_levname                 {   };  # [3] map of levidx to levname

lib/ControlBreak.pm  view on Meta::CPAN

A readonly field that provides the current iteration number.

This can be useful if you are doing an final processing after an
iteration loop has ended.  In the event that the data stream is empty
and there were no iterations, then you can condition your final
processing on iteration > 0.

Note that the B<interation> field is incremented by B<test()> (or
B<test_and_do()>). Therefore, when called within a loop it is
effectively zero-based if referenced within the iteration block

lib/ControlBreak.pm  view on Meta::CPAN

}

=head2 reset

Resets the state of the object so it can be used again for another
set of iterations using the same number and type of controls
establish when the object was instantiated with B<new()>.  Any
comparisons that were subsequently modified are retained.

=cut

 view release on metacpan or  search on metacpan

tests/601_speed.t  view on Meta::CPAN

-e $cache and unlink $cache;

# check "normal" C::B::C object
$tests = 5;
$next_test_time = 0;
$iterations = 0;
$start_time = mytime();
$elapsed_time = 0;
$fail = 0;
while ($elapsed_time < $required_time) {
  eval {
    $c = Convert::Binary::C->new( %$CCCFG );
    $c->parse_file( 'tests/include/include.c' );
  };
  $@ and $fail = 1 and last;
  $iterations++;
  $elapsed_time = mytime() - $start_time;

  # this is just to prevent the user from stopping the test
  if( $elapsed_time >= $next_test_time and $tests > 0 ) {
    $tests--;

tests/601_speed.t  view on Meta::CPAN

ok(1) while $tests-- > 0;

ok( $fail, 0, "failed to perform reference speed test ($@)" );

print "# uncached: $iterations iterations in $elapsed_time seconds\n";

# create cache file
eval {
  $c = Convert::Binary::C::Cached->new( Cache => $cache, %$CCCFG );

tests/601_speed.t  view on Meta::CPAN

ok( -e $cache );

# check cached object (this should be a lot faster)
$start_time = mytime();
eval {
  for( 1 .. $iterations ) {
    $c = Convert::Binary::C::Cached->new( Cache => $cache, %$CCCFG );
    $c->parse_file( 'tests/include/include.c' );
  }
};

ok( $@, '', "failed to perform cached speed test ($@)" );

$cached_time = mytime() - $start_time;
$speedup = $cached_time < 0.001 ? 1000 : $elapsed_time / $cached_time;

print "# cached: $iterations iterations in $cached_time seconds\n";
print "# speedup is $speedup\n";

# a speedup of 2 is acceptable
ok( $speedup > 2 );

 view release on metacpan or  search on metacpan

examples/transliterate.pl  view on Meta::CPAN

./transliterate.pl

=head1 DESCRIPTION

This is a simple demonstration script that presents transliterations,
and retransliterations between Coptic, Ethiopic, Greek and Hebrew.


=head1 AUTHOR

Daniel Yacob,  L<dyacob@cpan.org|mailto:dyacob@cpan.org>

 view release on metacpan or  search on metacpan

i-term.tbx  view on Meta::CPAN

        <langSet xml:lang="en" id="cid431">
          <descrip type="definition">way of spelling or writing lexemes that conforms to a conventionalized use</descrip>
          <admin type="source">ISO 24613 : 2006</admin>
          <descrip type="definition">Alt.def: </descrip>
          <admin type="source"/>
          <note>NOTE: Aside from standardized spellings of alphabetical languages, such as standard UK or US English, or reformed German spelling, there can be variations such as transliterations of languages in non-native scripts, stenographic rende...
          <note/>
          <note/>
          <transacGrp>
            <transac type="transactionType">origination</transac>
            <transacNote type="responsibility">Lindsay Martin (lindsay)</transacNote>

 view release on metacpan or  search on metacpan

uulib/crc32.c  view on Meta::CPAN

   *                       and crc(B') based on crc(B)
   * - since B' starts with many zeros, the crc of those initial zeros is still zero
   * - that means crc(B') = crc(B)
   * - unfortunately the trailing zeros of A' change the crc, so usually crc(A') != crc(A)
   * - the following code is a fast algorithm to compute crc(A')
   * - starting with crc(A) and appending length(B) zeros, needing just log2(length(B)) iterations
   * - the details are explained by the original author at
   *   https://stackoverflow.com/questions/23122312/crc-calculation-of-a-mostly-static-data-stream/23126768
   *
   * notes:
   * - I squeezed everything into one function to keep global namespace clean (original code two helper functions)

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

XS.xs  view on Meta::CPAN

                  else
                    has_utf8 = HeKUTF8(he);
                }
            }

          /* Undefined behaviour when the two iterations do not result in the same count.
             With threads::shared or broken tie. The last HEs might be NULL then or we'll
             miss some. */
          if (i != count)
            croak ("Unstable %shash key counts %d vs %d in subsequent runs",
                   is_tied ? "tied " : "", (int)count, (int)i);

 view release on metacpan or  search on metacpan

lib/Cron/Toolkit.pm  view on Meta::CPAN

   my $max_iter = $tm->delta_days($max_tm);

   # the brute force approach for DMY is correct here because:
   # 1) the design is simple and easy to understand and debug
   # 2) solves all tricky end-of-month and leap year calculations
   # 3) 365 iterations per one-year time window is good enough

   for my $day ( 1 .. $max_iter ) {
      return $tm->epoch if $self->_is_match($tm);
      $tm = $tm->plus_days(1);
   }

lib/Cron/Toolkit.pm  view on Meta::CPAN

   my $year_highval = $year_node->highest($tm);
   my $tm_year_high = $self->_set_date( $tm, $year_node->field_type, $year_highval );
   $tm_year_high    = $self->_plus_one( $tm_year_high, $year_node->field_type );
   $tm = $tm_year_high if $tm->is_after($tm_year_high);

   # calculate maximum iterations
   my $min_tm = Time::Moment->new(
      year   => 1970,
      month  => 1,
      day    => 1,
      hour   => 0,

 view release on metacpan or  search on metacpan

include/argon2.h  view on Meta::CPAN

 */
ARGON2_PUBLIC int argon2_ctx(argon2_context *context, argon2_type type);

/**
 * Hashes a password with Argon2i, producing an encoded hash
 * @param t_cost Number of iterations
 * @param m_cost Sets memory usage to m_cost kibibytes
 * @param parallelism Number of threads and compute lanes
 * @param pwd Pointer to password
 * @param pwdlen Password size in bytes
 * @param salt Pointer to salt

include/argon2.h  view on Meta::CPAN

                                       const size_t hashlen, char *encoded,
                                       const size_t encodedlen);

/**
 * Hashes a password with Argon2i, producing a raw hash at @hash
 * @param t_cost Number of iterations
 * @param m_cost Sets memory usage to m_cost kibibytes
 * @param parallelism Number of threads and compute lanes
 * @param pwd Pointer to password
 * @param pwdlen Password size in bytes
 * @param salt Pointer to salt

include/argon2.h  view on Meta::CPAN

 */
ARGON2_PUBLIC const char *argon2_error_message(int error_code);

/**
 * Returns the encoded hash length for the given input parameters
 * @param t_cost  Number of iterations
 * @param m_cost  Memory usage in kibibytes
 * @param parallelism  Number of threads; used to compute lanes
 * @param saltlen  Salt size in bytes
 * @param hashlen  Hash size in bytes
 * @param type The argon2_type that we want the encoded length for