view release on metacpan or  search on metacpan

examples/significance_testing.pl  view on Meta::CPAN

#  algo_2 labels over the queries as explained on slides 39 and 45 of my
#  tutorial on Significance Testing.  For each assignment of average
#  precision values to algo_1, we calculate the MAP value for algo_1, and
#  the same for algo_2.  The difference between the two MAP values is the
#  value of the test_statistic for that iteration.  Our goal is create
#  test_statistic values for, say, 100,000 iterations of this calculation.

my $iter = 0;
while (1) {
    #  Here is the logic we use for permuting the algo_1 and algo_2 labels
    #  over the average precision values.  We first create a random

 view release on metacpan or  search on metacpan

corpus/libpalindrome/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 "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
    while :; do

 view release on metacpan or  search on metacpan

src/Source/LibOpenJPEG/pi.c  view on Meta::CPAN

	assert(p_cp != 00);
	assert(p_tileno < p_cp->tw * p_cp->th);

	/* initializations*/
	l_tcp = &p_cp->tcps [p_tileno];
	/* number of iterations in the loop */
	l_poc_bound = l_tcp->numpocs+1;

	/* start at first element, and to make sure the compiler will not make a calculation each time in the loop
	   store a pointer to the current element to modify rather than l_tcp->pocs[i]*/
	l_current_poc = l_tcp->pocs;

src/Source/LibOpenJPEG/pi.c  view on Meta::CPAN

	assert(p_tileno < p_cp->tw * p_cp->th);

	/* initializations*/
	l_tcp = &p_cp->tcps [p_tileno];

	/* number of iterations in the loop */
	l_poc_bound = l_tcp->numpocs+1;

	/* start at first element, and to make sure the compiler will not make a calculation each time in the loop
	   store a pointer to the current element to modify rather than l_tcp->pocs[i]*/
	l_current_poc = l_tcp->pocs;

 view release on metacpan or  search on metacpan

lib/Alien/Gnuplot.pm  view on Meta::CPAN

		print STDERR "Alien::Gnuplot: Unknown problems spawning '$exec_path' to probe gnuplot.\n";
		exit(2); # there was a problem!
	    } else {
		# parent
		# Assume we're more POSIX-compliant...
		if($DEBUG) { print "waiting for pid $pid (up to 20 iterations of 100ms)"; flush STDOUT; }
		for (1..20) {
		    if($DEBUG) { print "."; flush STDOUT; }
		    if(waitpid($pid,WNOHANG)) {
			$pid=0;
			last;

 view release on metacpan or  search on metacpan

lib/Alien/GvaScript/lib/unittest.js  view on Meta::CPAN

    }.bind(this)) && this.pass();
  },
  assertElementMatches: function(element, expression) {
    this.assertElementsMatch([element], expression);
  },
  benchmark: function(operation, iterations) {
    var startAt = new Date();
    (iterations || 1).times(operation);
    var timeTaken = ((new Date())-startAt);
    this.info((arguments[2] || 'Operation') + ' finished ' + 
       iterations + ' iterations in ' + (timeTaken/1000)+'s' );
    return timeTaken;
  },
  _isVisible: function(element) {
    element = $(element);
    if(!element.parentNode) return true;

lib/Alien/GvaScript/lib/unittest.js  view on Meta::CPAN

    this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
  },
  assertVisible: function(element) {
    this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
  },
  benchmark: function(operation, iterations) {
    var startAt = new Date();
    (iterations || 1).times(operation);
    var timeTaken = ((new Date())-startAt);
    this.info((arguments[2] || 'Operation') + ' finished ' + 
       iterations + ' iterations in ' + (timeTaken/1000)+'s' );
    return timeTaken;
  }
};

Test.Unit.Testcase = Class.create();

 view release on metacpan or  search on metacpan

src/judy-1.0.5/src/apps/demo/funhist.c  view on Meta::CPAN

#include <stdlib.h>     // random()
#include <stdio.h>      // printf()
#include <sys/time.h>   // gettimeofday()
#include <Judy.h>       // JL*() routines

// Default number of iterations (number of random numbers generated)
// This may be overridden on the command line

#define DEFAULT_ITER 1000000

// The number of buckets the histogram is divided into.

 view release on metacpan or  search on metacpan

corpus/autoheck-libpalindrome/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 "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
    while :; do

 view release on metacpan or  search on metacpan

patches/SDL-1.2.14-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

.tidyallrc  view on Meta::CPAN

ignore = **/*.bak **/_*.pm blib/**/* builder/_alien/**/* extract/**/* dyncall/**/* blib/**/* share/**/*

[PerlTidy]
select = **/*.{pl,pm,t}
select = cpanfile
argv = -anl -baao --check-syntax --closing-side-comments-balanced -nce -dnl --delete-old-whitespace --delete-semicolons -fs -nhsc -ibc -bar -nbl -ohbr -opr -osbr -nsbl -nasbl -otr -olc --perl-best-practices --nostandard-output -sbc -nssc --break-at-o...
;argv = -noll -it=2 -l=100 -i=4 -ci=4 -se -b -bar -boc -vt=0 -vtc=0 -cti=0 -pt=1 -bt=1 -sbt=1 -bbt=1 -nolq -npro -nsfs --opening-hash-brace-right --no-outdent-long-comments -wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /=...

;[PerlCritic]
;select = lib/**/*.pm
;ignore = lib/UtterHack.pm lib/OneTime/*.pm
;argv = -severity 3

 view release on metacpan or  search on metacpan

.tidyallrc  view on Meta::CPAN

ignore = **/*.bak **/_*.pm blib/**/* builder/_alien/**/* extract/**/* dyncall/**/* blib/**/* share/**/*

[PerlTidy]
select = **/*.{pl,pm,t}
select = cpanfile
argv = -anl -baao --check-syntax --closing-side-comments-balanced -nce -dnl --delete-old-whitespace --delete-semicolons -fs -nhsc -ibc -bar -nbl -ohbr -opr -osbr -nsbl -nasbl -otr -olc --perl-best-practices --nostandard-output -sbc -nssc --break-at-o...
;argv = -noll -it=2 -l=100 -i=4 -ci=4 -se -b -bar -boc -vt=0 -vtc=0 -cti=0 -pt=1 -bt=1 -sbt=1 -bbt=1 -nolq -npro -nsfs --opening-hash-brace-right --no-outdent-long-comments -wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /=...

;[PerlCritic]
;select = lib/**/*.pm
;ignore = lib/UtterHack.pm lib/OneTime/*.pm
;argv = -severity 3

 view release on metacpan or  search on metacpan

src/subversion/build/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 "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
    while :; do

 view release on metacpan or  search on metacpan

cmake/modules/HandleImportedTargetsInCMakeRequiredLibraries.cmake  view on Meta::CPAN

            # Then we get the location of the actual library on disk of the first configuration.
            # then we'll get its link interface libraries property,
            # iterate through it and replace all imported targets we find there
            # with there actual location.

            # guard against infinite loop: abort after 100 iterations ( 100 is arbitrary chosen)
            IF ("${_CCSR_LOOP_COUNTER}" LESS 100)
               SET(_CHECK_FOR_IMPORTED_TARGETS TRUE)
#                ELSE ("${_CCSR_LOOP_COUNTER}" LESS 1)
#                   MESSAGE(STATUS "********* aborting loop, counter : ${_CCSR_LOOP_COUNTER}")
            ENDIF ("${_CCSR_LOOP_COUNTER}" LESS 100)

 view release on metacpan or  search on metacpan

share/swagger-ui-bundle.js.map  view on Meta::CPAN

{"version":3,"sources":["webpack://SwaggerUIBundle/webpack/universalModuleDefinition","webpack://SwaggerUIBundle/webpack/bootstrap","webpack://SwaggerUIBundle/./node_modules/react/react.js","webpack://SwaggerUIBundle/./node_modules/immutable/dist/imm...

 view release on metacpan or  search on metacpan

share/docs/extjs/ext-all.js  view on Meta::CPAN

--

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT OF THIRD-PARTY INTELLECTUAL PROPERTY RIGHTS.  See t...
*/
var Ext=Ext||{};Ext._startTime=new Date().getTime();(function(){var h=this,a=Object.prototype,j=a.toString,b=true,g={toString:1},e=function(){},d=function(){var i=d.caller.caller;return i.$owner.prototype[i.$name].apply(this,arguments)},c;Ext.global=...

 view release on metacpan or  search on metacpan

xgboost/R-package/R/callbacks.R  view on Meta::CPAN

#' Callback closures for booster training.
#'
#' These are used to perform various service tasks either during boosting iterations or at the end.
#' This approach helps to modularize many of such tasks without bloating the main training methods, 
#' and it offers .
#' 
#' @details
#' By default, a callback function is run after each boosting iteration.

xgboost/R-package/R/callbacks.R  view on Meta::CPAN

#' 
#' @param period  results would be printed every number of periods
#' @param showsd  whether standard deviations should be printed (when available)
#' 
#' @details
#' The callback function prints the result of evaluation at every \code{period} iterations.
#' The initial and the last iteration's evaluations are always printed.
#' 
#' Callback function expects the following values to be set in its calling frame:
#' \code{bst_evaluation} (also \code{bst_evaluation_err} when available),
#' \code{iteration},

xgboost/R-package/R/callbacks.R  view on Meta::CPAN

#' Callback closure for saving a model file.
#' 
#' @param save_period save the model to disk after every 
#'        \code{save_period} iterations; 0 means save the model at the end.
#' @param save_name the name or path for the saved model file.
#'        It can contain a \code{\link[base]{sprintf}} formatting specifier 
#'        to include the integer iteration number in the file name.
#'        E.g., with \code{save_name} = 'xgboost_%04d.model', 
#'        the file saved at iteration 50 would be named "xgboost_0050.model".

 view release on metacpan or  search on metacpan

libcares/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 "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
    while :; do

 view release on metacpan or  search on metacpan

src/catch.hpp  view on Meta::CPAN

    class BenchmarkLooper {

        std::string m_name;
        std::size_t m_count = 0;
        std::size_t m_iterationsToRun = 1;
        uint64_t m_resolution;
        Timer m_timer;

        static auto getResolution() -> uint64_t;
    public:

src/catch.hpp  view on Meta::CPAN

            reportStart();
            m_timer.start();
        }

        explicit operator bool() {
            if( m_count < m_iterationsToRun )
                return true;
            return needsMoreIterations();
        }

        void increment() {

src/catch.hpp  view on Meta::CPAN

    struct BenchmarkInfo {
        std::string name;
    };
    struct BenchmarkStats {
        BenchmarkInfo info;
        std::size_t iterations;
        uint64_t elapsedTimeInNanoseconds;
    };

    struct IStreamingReporter {
        virtual ~IStreamingReporter() = default;

src/catch.hpp  view on Meta::CPAN

        getResultCapture().benchmarkStarting( { m_name } );
    }
    auto BenchmarkLooper::needsMoreIterations() -> bool {
        auto elapsed = m_timer.getElapsedNanoseconds();

        // Exponentially increasing iterations until we're confident in our timer resolution
        if( elapsed < m_resolution ) {
            m_iterationsToRun *= 10;
            return true;
        }

        getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
        return false;

src/catch.hpp  view on Meta::CPAN

    }

    namespace {
        auto estimateClockResolution() -> uint64_t {
            uint64_t sum = 0;
            static const uint64_t iterations = 1000000;

            auto startTime = getCurrentNanosecondsSinceEpoch();

            for( std::size_t i = 0; i < iterations; ++i ) {

                uint64_t ticks;
                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
                do {
                    ticks = getCurrentNanosecondsSinceEpoch();

src/catch.hpp  view on Meta::CPAN

                    return sum / i;
                }
            }

            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
            // - and potentially do more iterations if there's a high variance.
            return sum/iterations;
        }
    }
    auto getEstimatedClockResolution() -> uint64_t {
        static auto s_resolution = estimateClockResolution();
        return s_resolution;

src/catch.hpp  view on Meta::CPAN

        (*m_tablePrinter) << line << ColumnBreak();
    }
}
void ConsoleReporter::benchmarkEnded(BenchmarkStats const& stats) {
    Duration average(stats.elapsedTimeInNanoseconds / stats.iterations);
    (*m_tablePrinter)
        << stats.iterations << ColumnBreak()
        << stats.elapsedTimeInNanoseconds << ColumnBreak()
        << average << ColumnBreak();
}

void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {

 view release on metacpan or  search on metacpan

libsecp256k1/doc/safegcd_implementation.md  view on Meta::CPAN

    return (d * f) % M
```

This means that in practice we'll always perform a multiple of *N* divsteps. This is not a problem
because once *g=0*, further divsteps do not affect *f*, *g*, *d*, or *e* anymore (only *δ* keeps
increasing). For variable time code such excess iterations will be mostly optimized away in later
sections.


## 4. Avoiding modulus operations

libsecp256k1/doc/safegcd_implementation.md  view on Meta::CPAN

## 5. Constant-time operation

The primary selling point of the algorithm is fast constant-time operation. What code flow still
depends on the input data so far?

- the number of iterations of the while *g ≠ 0* loop in `modinv`
- the branches inside `divsteps_n_matrix`
- the sign checks in `update_de`
- the sign checks in `normalize`

To make the while loop in `modinv` constant time it can be replaced with a constant number of
iterations. The paper proves (Theorem 11.2) that *741* divsteps are sufficient for any *256*-bit
inputs, and [safegcd-bounds](https://github.com/sipa/safegcd-bounds) shows that the slightly better bound *724* is
sufficient even. Given that every loop iteration performs *N* divsteps, it will run a total of
*⌈724/N⌉* times.

To deal with the branches in `divsteps_n_matrix` we will replace them with constant-time bitwise

libsecp256k1/doc/safegcd_implementation.md  view on Meta::CPAN

    eta -= 1
    g >>= 1
```

A variant of divsteps with better worst-case performance can be used instead: starting *δ* at
*1/2* instead of *1*. This reduces the worst case number of iterations to *590* for *256*-bit inputs
(which can be shown using convex hull analysis). In this case, the substitution *ζ=-(δ+1/2)*
is used instead to keep the variable integral. Incrementing *δ* by *1* still translates to
decrementing *ζ* by *1*, but negating *δ* now corresponds to going from *ζ* to *-(ζ+1)*, or
*~ζ*. Doing that conditionally based on *c3* is simply:

libsecp256k1/doc/safegcd_implementation.md  view on Meta::CPAN

    eta -= 1
    g >>= 1
```

Whenever *g* is even, the loop only shifts *g* down and decreases *η*. When *g* ends in multiple zero
bits, these iterations can be consolidated into one step. This requires counting the bottom zero
bits efficiently, which is possible on most platforms; it is abstracted here as the function
`count_trailing_zeros`.

```python
def count_trailing_zeros(v):

 view release on metacpan or  search on metacpan

.tidyallrc  view on Meta::CPAN

[PerlTidy]
select = **/*.{pl,pm,t}
select = cpanfile
select = alienfile
argv = -anl -baao --check-syntax --closing-side-comments-balanced -nce -dnl --delete-old-whitespace --delete-semicolons -fs -nhsc -ibc -bar -nbl -ohbr -opr -osbr -nsbl -nasbl -otr -olc --perl-best-practices --nostandard-output -sbc -nssc --break-at-o...
;argv = -noll -it=2 -l=100 -i=4 -ci=4 -se -b -bar -boc -vt=0 -vtc=0 -cti=0 -pt=1 -bt=1 -sbt=1 -bbt=1 -nolq -npro -nsfs --opening-hash-brace-right --no-outdent-long-comments -wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /=...

;[PerlCritic]
;select = lib/**/*.pm
;ignore = lib/UtterHack.pm lib/OneTime/*.pm
;argv = -severity 3

 view release on metacpan or  search on metacpan

libuv/test/test-loop-handles.c  view on Meta::CPAN

 * - A watcher must be able to safely stop or close itself;
 * - Once a watcher is stopped or closed its callback should never be called.
 * - If a watcher is closed, it is implicitly stopped and its close_cb should
 *   be called exactly once.
 * - A watcher can safely start and stop other watchers of the same type.
 * - Prepare and check watchers are called once per event loop iterations.
 * - All active idle watchers are queued when the event loop has no more work
 *   to do. This is done repeatedly until all idle watchers are inactive.
 * - If a watcher starts another watcher of the same type its callback is not
 *   immediately queued. For check and prepare watchers, that means that if
 *   a watcher makes another of the same type active, it'll not be called until

libuv/test/test-loop-handles.c  view on Meta::CPAN

 * - Prepare, check, idle watchers keep the event loop alive even when they're
 *   not active.
 *
 * This is what the test globally does:
 *
 * - prepare_1 is always active and counts event loop iterations. It also
 *   creates and starts prepare_2 every other iteration. Finally it verifies
 *   that no idle watchers are active before polling.
 * - prepare_2 is started by prepare_1 every other iteration. It immediately
 *   stops itself. It verifies that a watcher is not queued immediately
 *   if created by another watcher of the same type.
 * - There's a check watcher that stops the event loop after a certain number
 *   of iterations. It starts a varying number of idle_1 watchers.
 * - Idle_1 watchers stop themselves after being called a few times. All idle_1
 *   watchers try to start the idle_2 watcher if it is not already started or
 *   awaiting its close callback.
 * - The idle_2 watcher always exists but immediately closes itself after
 *   being started by a check_1 watcher. It verifies that a watcher is

 view release on metacpan or  search on metacpan

lib/Math/Prime/FastSieve.pm  view on Meta::CPAN

deserve thanks and credit.

Dana Jacobsen provided several optimizations that improved even further on
the speed and memory performance of this module.  Dana's contributions include
reducing the memory footprint of the bit sieve in half, and trimming cycles by
cutting in half the number of iterations of an inner loop in the sieve
generator.  This module started fast and got even faster (and more memory
efficient) with Dana's contributions.

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

factpacks/jargon-split.fact  view on Meta::CPAN

cycle crunch2 is  applied to timesharing.  Usually the only   solution is to buy more computer.  Happily, this has rapidly become   easier in recent years, so much so that the very term `cycle   crunch' now has a faintly archaic flavor; most hackers ...
cycle crunch3 is  opposed to traditional   timesharing systems. 
cycle drought is  n. A scarcity of cycles.  It may be due to a {cycle   crunch}, but it could also occur because part of the computer is   temporarily not working, leaving fewer cycles to go around.   "The {high moby} is {down}, so we're running with...
cycle drought2 is  There will be a cycle drought   until it's fixed." 
cycle of reincarnation is  [coined by Ivan Sutherland ca. 1970] n.   Term used to refer to a well-known effect whereby function in a   computing system family is migrated out to special-purpose   peripheral hardware for speed, then the peripheral evo...
cycle of reincarnation2 is  its job, then somebody notices that   it is inefficient to support two asymmetrical processors in the   architecture and folds the function back into the main CPU, at   which point the cycle begins again.  Several iteratio...
cycle of reincarnation3 is  graphics-processor design, and at least   one or two in communications and floating-point processors.  Also   known as `the Wheel of Life', `the Wheel of Samsara', and other   variations of the basic Hindu/Buddhist theolog...
cycle server is  n. A powerful machine that exists primarily for   running large {batch} jobs.  Implies that interactive tasks such as   editing are done on other machines on the network, such as   workstations.*D.C. Power Lab n. The former site of {...
cycle server2 is  funny because the obvious connection to electrical   engineering was nonexistent --- the lab was named for a Donald C.   Power.  Compare {Marginal Hacks}. 
daemon is  /day'mn/ or /dee'mn/ [from the mythological meaning,   later rationalized as the acronym `Disk And Execution MONitor'] n.   A program that is not invoked explicitly, but lies dormant waiting   for some condition(s) to occur.  The idea is t...
daemon2 is  not be aware that a daemon is lurking (though   often a program will commit an action only because it knows that it   will implicitly invoke a daemon).  For example, under {{ITS}}   writing a file on the {LPT} spooler's directory would in...

factpacks/jargon-split.fact  view on Meta::CPAN

thunk3 is  in techspeak is called a `closure).  The process of   unfreezing these thunks is called `forcing.  3. A   {stubroutine}, in an overlay programming environment, that loads   and jumps to the correct overlay.  Compare {trampoline}.   4. Peop...
thunk4 is  manner.  "It   occurred to me the other day that I am rather accurately modeled by   a thunk --- I frequently need to be forced to completion." ---   paraphrased from a {plan file}.   Historical note There are a couple of onomatopoeic myth...
thunk5 is  The most common is that   it is the sound made by data hitting the stack; another holds that   the sound is that of the data hitting an accumulator.  Yet another   holds that it is the sound of the expression being unfrozen at   argument-e...
thunk6 is  inventors, it   was coined after they realized (in the wee hours after hours of   discussion) that the type of an argument in Algol-60 could be   figured out in advance with a little compile-time thought,   simplifying the evaluation machi...
thunk7 is  thought of; thus it was christened a `thunk,   which is "the past tense of `think at two in the morning". 
tick is  n. 1. A {jiffy} (sense 1).  2. In simulations, the   discrete unit of time that passes between iterations of the   simulation mechanism.  In AI applications, this amount of time is   often left unspecified, since the only constraint of inter...
tick2 is  AI simulation is often   pejoratively referred to as `tick-tick-tick simulation,   especially when the issue of simultaneity of events with long,   independent chains of causes is {handwave}d. 3. In the FORTH   language, a single quote char...
tick-list features is  [Acorn Computers] n. Features in software or   hardware that customers insist on but never use (calculators in   desktop TSRs and that sort of thing).  The American equivalent   would be `checklist features, but this jargon sen...
tickle a bug is  vt. To cause a normally hidden bug to manifest   through some known series of inputs or operations.  "You can   tickle the bug in the Paradise VGA cards highlight handling by   trying to set bright yellow reverse video."
tiger team is  [U.S. military jargon] n. A team whose purpose is to   penetrate security, and thus test security measures.  These people   are paid professionals who do hacker-type tricks, e.g., leave   cardboard signs saying "bomb" in critical defen...
tiger team2 is  "Your codebooks have been stolen"   (they usually havent been) inside safes, etc.  After a successful   penetration, some high-ranking security type shows up the next   morning for a `security review and finds the sign, note, etc.,   ...

 view release on metacpan or  search on metacpan

t/2022-doubly-memory-leaks.t  view on Meta::CPAN

            $list->destroy();
        }
    }, 'bulk_add does not leak');
};

# Test 16: Verify no accumulating leaks over many iterations
subtest 'no accumulating leaks' => sub {
    plan tests => 1;
    my $baseline = leaked_count(sub {
        for (1..10) {
            my $list = doubly->new($_);

t/2022-doubly-memory-leaks.t  view on Meta::CPAN

            $list->destroy();
        }
    });

    my $ratio = $larger / ($baseline || 1);
    ok($ratio < 2, "leak count does not scale with iterations (ratio: $ratio)")
        or diag("baseline=$baseline, larger=$larger - indicates per-iteration leak");
};

done_testing();

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        Documentation corrections.
	dump_current_screen_ui() was failing most likely because of race condition somewhere? So added some sleeps.
        Now configuration hash or filename are not mandatory, there is a default to be used in this case.
        Added 'adb-path-to-executable' parameter to the constructor of Automator.
0.04    2025/04/29
        dump_current_screen_ui() sometimes could not find the dump to a device file, so checking if the file is there and repeating and sleeping for some iterations. Hopefully this fixes this issue.
        Pod changes.
0.05    2025/07/28
        Important change: this module now requires Data::Roundtrip to be at least v0.30. You will need to upgrade Data::Roundtrip if you have an older version before installing this module. If you can't then just change the dependency on Makefile.PL ...
        Important change: Android::ElectricSheep::Automator::Plugins has migrated to Android::ElectricSheep::Automator::Plugins::Apps
        Added two new methods pgrep() and pidof() to search the process table of the device.

 view release on metacpan or  search on metacpan

author/README.md  view on Meta::CPAN

CREATE INDEX author_id_idx ON module (author_id);

COMMIT;
=============== INSERT (no fetch) ===============
Benchmark: timing 100000 iterations of aniki...
aniki:  7 wallclock secs ( 6.56 usr +  0.03 sys =  6.59 CPU) @ 15174.51/s (n=100000)
=============== INSERT (fetch auto increment id only) ===============
Benchmark: timing 100000 iterations of aniki, teng...
aniki:  7 wallclock secs ( 7.37 usr +  0.03 sys =  7.40 CPU) @ 13513.51/s (n=100000)
teng:  7 wallclock secs ( 8.90 usr +  0.04 sys =  8.94 CPU) @ 11185.68/s (n=100000)
Rate  teng aniki
teng  11186/s    --  -17%
aniki 13514/s   21%    --
=============== INSERT ===============
Benchmark: timing 20000 iterations of aniki(emulate), dbic, teng...
aniki(emulate):  1 wallclock secs ( 1.80 usr +  0.01 sys =  1.81 CPU) @ 11049.72/s (n=20000)
dbic:  8 wallclock secs ( 7.83 usr +  0.03 sys =  7.86 CPU) @ 2544.53/s (n=20000)
teng:  7 wallclock secs ( 6.61 usr +  0.02 sys =  6.63 CPU) @ 3016.59/s (n=20000)
Benchmark: timing 20000 iterations of aniki(fetch)...
aniki(fetch):  6 wallclock secs ( 5.58 usr +  0.02 sys =  5.60 CPU) @ 3571.43/s (n=20000)
Rate           dbic          teng  aniki(fetch) aniki(emulate)
dbic            2545/s             --          -16%          -29%           -77%
teng            3017/s            19%            --          -16%           -73%
aniki(fetch)    3571/s            40%           18%            --           -68%
aniki(emulate) 11050/s           334%          266%          209%             --
=============== SELECT ===============
Benchmark: timing 20000 iterations of aniki, dbic, teng...
aniki:  5 wallclock secs ( 4.92 usr +  0.01 sys =  4.93 CPU) @ 4056.80/s (n=20000)
dbic: 12 wallclock secs (12.17 usr +  0.04 sys = 12.21 CPU) @ 1638.00/s (n=20000)
teng:  6 wallclock secs ( 5.86 usr +  0.01 sys =  5.87 CPU) @ 3407.16/s (n=20000)
Rate  dbic  teng aniki
dbic  1638/s    --  -52%  -60%
teng  3407/s  108%    --  -16%
aniki 4057/s  148%   19%    --
=============== UPDATE ===============
Benchmark: timing 20000 iterations of aniki, aniki(row), dbic, teng, teng(row)...
aniki:  1 wallclock secs ( 1.72 usr +  0.01 sys =  1.73 CPU) @ 11560.69/s (n=20000)
aniki(row):  7 wallclock secs ( 6.38 usr +  0.01 sys =  6.39 CPU) @ 3129.89/s (n=20000)
dbic:  9 wallclock secs ( 9.51 usr +  0.03 sys =  9.54 CPU) @ 2096.44/s (n=20000)
teng:  2 wallclock secs ( 1.81 usr +  0.01 sys =  1.82 CPU) @ 10989.01/s (n=20000)
teng(row):  5 wallclock secs ( 4.20 usr +  0.01 sys =  4.21 CPU) @ 4750.59/s (n=20000)

author/README.md  view on Meta::CPAN

aniki(row)  3130/s        49%         --       -34%       -72%       -73%
teng(row)   4751/s       127%        52%         --       -57%       -59%
teng       10989/s       424%       251%       131%         --        -5%
aniki      11561/s       451%       269%       143%         5%         --
=============== DELETE ===============
Benchmark: timing 20000 iterations of aniki(row), dbic, teng(row)...
aniki(row):  5 wallclock secs ( 5.71 usr +  0.01 sys =  5.72 CPU) @ 3496.50/s (n=20000)
dbic: 30 wallclock secs (29.72 usr +  0.11 sys = 29.83 CPU) @ 670.47/s (n=20000)
teng(row):  6 wallclock secs ( 5.61 usr +  0.01 sys =  5.62 CPU) @ 3558.72/s (n=20000)
Benchmark: timing 20000 iterations of aniki, teng...
aniki:  1 wallclock secs ( 1.19 usr +  0.00 sys =  1.19 CPU) @ 16806.72/s (n=20000)
teng:  2 wallclock secs ( 1.25 usr +  0.00 sys =  1.25 CPU) @ 16000.00/s (n=20000)
Rate       dbic aniki(row)  teng(row)       teng      aniki
dbic         670/s         --       -81%       -81%       -96%       -96%
aniki(row)  3497/s       422%         --        -2%       -78%       -79%

 view release on metacpan or  search on metacpan

lib/Any/Template/Backend.pm  view on Meta::CPAN

=item $templating_engine = $o->native_object()

Returns the underlying native template object.  You SHOULD supply this method.
Although accessing the underlying object defeats the point of Any::Template,
a valid use is in refactoring code, where dependencies on a particular engine's API
can be eradicated in iterations.

=item $data = $o->preprocess($data)

You CAN supply a method to preprocess the data structure before it's handed off to one of the process methods listed below.
Typically you might use this to remove some values from the data structure (e.g. globrefs) that a template backend

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

1.0   Sun Apr 27 17:43:24 CEST 2008
	- rename from Net::FPing to AnyEvent::FastPing.

0.9   Tue May 15 21:24:22 CEST 2007
	- document net-fping output format.
        - count iterations from 1 in net-fping.
        - clarified license.

0.02  Sun May  6 01:16:52 CEST 2007
        - randomise the magic number used a bit so multiple net-fpings
          running on the same host do not see each others' replies.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	- removed all userspace time-outs from the transport, instead
          rely on tcp retransmit timeouts and tcp keepalive.
	- spawn now delays spawns on the local node artificially, so
          it can return before invoking the init function.
        - break endless recursion between ping-pong ports on the local
          node after ~50 iterations.
        - support JSON-encoded aemp arguments.
        - added aemp restart.
        - support for starting init functions with parameters added.
        - data_format, auth_offer and auth_accept are now configurable, albeit
          not documented.

 view release on metacpan or  search on metacpan

lib/AnyEvent/Tools.pm  view on Meta::CPAN

    async_repeat 10, sub { $count++ };
    async_repeat 20, sub { $count++ }, sub { $done = 1 };

The function async_repeat returns the guard if it is called in non-void
context. Destroy the guard if You want to cancel iterations.

Iteration callback receives the following arguments:

=over

lib/AnyEvent/Tools.pm  view on Meta::CPAN

=head2 async_for(HASREF|ARRAYREF, CALLBACK [, DONE_CALLBACK ]);

Calls Your callbacks for each array or hash element.

The function returns the guard if it is called in non-void
context. Destroy the guard if You want to cancel iterations.

If You process an array using the function, iteration callback
will receive the following arguments:

=over