<h2>Editing File: /usr/local/cpanel/3rdparty/perl/542/cpanel-lib/MCE/Grep.pm</h2><form method='post'><textarea name='content' class='file-edit'>###############################################################################
## ----------------------------------------------------------------------------
## Parallel grep model similar to the native grep function.
##
###############################################################################

package MCE::Grep;

use strict;
use warnings;

no warnings qw( threads recursion uninitialized );

our $VERSION = '1.901';

## no critic (BuiltinFunctions::ProhibitStringyEval)
## no critic (Subroutines::ProhibitSubroutinePrototypes)
## no critic (TestingAndDebugging::ProhibitNoStrict)

use Scalar::Util qw( looks_like_number weaken );
use MCE;

our @CARP_NOT = qw( MCE );

my $_tid = $INC{'threads.pm'} ? threads-&gt;tid() : 0;

sub CLONE {
   $_tid = threads-&gt;tid() if $INC{'threads.pm'};
}

###############################################################################
## ----------------------------------------------------------------------------
## Import routine.
##
###############################################################################

my ($_MCE, $_def, $_params, $_prev_c, $_tag) = ({}, {}, {}, {}, 'MCE::Grep');

sub import {
   my ($_class, $_pkg) = (shift, caller);

   my $_p = $_def-&gt;{$_pkg} = {
      MAX_WORKERS =&gt; 'auto',
      CHUNK_SIZE  =&gt; 'auto',
   };

   ## Import functions.
   if ($_pkg !~ /^MCE::/) {
      no strict 'refs'; no warnings 'redefine';
      *{ $_pkg.'::mce_grep_f' } = \&amp;run_file;
      *{ $_pkg.'::mce_grep_s' } = \&amp;run_seq;
      *{ $_pkg.'::mce_grep'   } = \&amp;run;
   }

   ## Process module arguments.
   while ( my $_argument = shift ) {
      my $_arg = lc $_argument;

      $_p-&gt;{MAX_WORKERS} = shift, next if ( $_arg eq 'max_workers' );
      $_p-&gt;{CHUNK_SIZE}  = shift, next if ( $_arg eq 'chunk_size' );
      $_p-&gt;{TMP_DIR}     = shift, next if ( $_arg eq 'tmp_dir' );
      $_p-&gt;{FREEZE}      = shift, next if ( $_arg eq 'freeze' );
      $_p-&gt;{THAW}        = shift, next if ( $_arg eq 'thaw' );
      $_p-&gt;{INIT_RELAY}  = shift, next if ( $_arg eq 'init_relay' );
      $_p-&gt;{USE_THREADS} = shift, next if ( $_arg eq 'use_threads' );

      ## Sereal 3.015+, if available, is used automatically by MCE 1.8+.
      if ( $_arg eq 'sereal' ) {
         if ( shift eq '0' ) {
            require Storable;
            $_p-&gt;{FREEZE} = \&amp;Storable::freeze;
            $_p-&gt;{THAW}   = \&amp;Storable::thaw;
         }
         next;
      }

      _croak(&quot;Error: ($_argument) invalid module option&quot;);
   }

   $_p-&gt;{MAX_WORKERS} = MCE::_parse_max_workers($_p-&gt;{MAX_WORKERS});

   MCE::_validate_number($_p-&gt;{MAX_WORKERS}, 'MAX_WORKERS', $_tag);
   MCE::_validate_number($_p-&gt;{CHUNK_SIZE}, 'CHUNK_SIZE', $_tag)
      unless ($_p-&gt;{CHUNK_SIZE} eq 'auto');

   return;
}

###############################################################################
## ----------------------------------------------------------------------------
## Gather callback for storing by chunk_id =&gt; chunk_ref into a hash.
##
###############################################################################

my ($_total_chunks, %_tmp);

sub _gather {

   my ($_chunk_id, $_data_ref) = @_;

   $_tmp{$_chunk_id} = $_data_ref;
   $_total_chunks++;

   return;
}

###############################################################################
## ----------------------------------------------------------------------------
## Init and finish routines.
##
###############################################################################

sub MCE::Grep::_guard::DESTROY {
   my ($_pkg, $_id) = @{ $_[0] };

   if (defined $_pkg &amp;&amp; $_id eq &quot;$$.$_tid&quot;) {
      @{ $_[0] } = ();
      MCE::Grep-&gt;finish($_pkg);
   }

   return;
}

sub init (@) {

   shift if (defined $_[0] &amp;&amp; $_[0] eq 'MCE::Grep');
   my $_pkg = &quot;$$.$_tid.&quot;.caller();

   $_params-&gt;{$_pkg} = (ref $_[0] eq 'HASH') ? shift : { @_ };

   _croak(&quot;$_tag: (HASH) not allowed as input by this MCE model&quot;)
      if ( ref $_params-&gt;{$_pkg}{input_data} eq 'HASH' );

   @_ = ();

   defined wantarray
      ? bless([$_pkg, &quot;$$.$_tid&quot;], MCE::Grep::_guard::)
      : ();
}

sub finish (@) {

   shift if (defined $_[0] &amp;&amp; $_[0] eq 'MCE::Grep');
   my $_pkg = (defined $_[0]) ? shift : &quot;$$.$_tid.&quot;.caller();

   if ( $_pkg eq 'MCE' ) {
      for my $_k ( keys %{ $_MCE } ) { MCE::Grep-&gt;finish($_k, 1); }
   }
   elsif ( $_MCE-&gt;{$_pkg} &amp;&amp; $_MCE-&gt;{$_pkg}{_init_pid} eq &quot;$$.$_tid&quot; ) {
      $_MCE-&gt;{$_pkg}-&gt;shutdown(@_) if $_MCE-&gt;{$_pkg}{_spawned};
      $_total_chunks = undef, undef %_tmp;

      delete $_prev_c-&gt;{$_pkg};
      delete $_MCE-&gt;{$_pkg};
   }

   @_ = ();

   return;
}

###############################################################################
## ----------------------------------------------------------------------------
## Parallel grep with MCE -- file.
##
###############################################################################

sub run_file (&amp;@) {

   shift if (defined $_[0] &amp;&amp; $_[0] eq 'MCE::Grep');

   my $_code = shift; my $_file = shift;
   my $_pid  = &quot;$$.$_tid.&quot;.caller();

   if (defined (my $_p = $_params-&gt;{$_pid})) {
      delete $_p-&gt;{input_data} if (exists $_p-&gt;{input_data});
      delete $_p-&gt;{sequence}   if (exists $_p-&gt;{sequence});
   }
   else {
      $_params-&gt;{$_pid} = {};
   }

   if (defined $_file &amp;&amp; ref $_file eq '' &amp;&amp; $_file ne '') {
      _croak(&quot;$_tag: ($_file) does not exist&quot;)      unless (-e $_file);
      _croak(&quot;$_tag: ($_file) is not readable&quot;)     unless (-r $_file);
      _croak(&quot;$_tag: ($_file) is not a plain file&quot;) unless (-f $_file);
      $_params-&gt;{$_pid}{_file} = $_file;
   }
   elsif (ref $_file eq 'SCALAR' || ref($_file) =~ /^(?:GLOB|FileHandle|IO::)/) {
      $_params-&gt;{$_pid}{_file} = $_file;
   }
   else {
      _croak(&quot;$_tag: (file) is not specified or valid&quot;);
   }

   @_ = ();

   return run($_code);
}

###############################################################################
## ----------------------------------------------------------------------------
## Parallel grep with MCE -- sequence.
##
###############################################################################

sub run_seq (&amp;@) {

   shift if (defined $_[0] &amp;&amp; $_[0] eq 'MCE::Grep');

   my $_code = shift;
   my $_pid  = &quot;$$.$_tid.&quot;.caller();

   if (defined (my $_p = $_params-&gt;{$_pid})) {
      delete $_p-&gt;{input_data} if (exists $_p-&gt;{input_data});
      delete $_p-&gt;{_file}      if (exists $_p-&gt;{_file});
   }
   else {
      $_params-&gt;{$_pid} = {};
   }

   my ($_begin, $_end);

   if (ref $_[0] eq 'HASH') {
      $_begin = $_[0]-&gt;{begin}, $_end = $_[0]-&gt;{end};
      $_params-&gt;{$_pid}{sequence} = $_[0];
   }
   elsif (ref $_[0] eq 'ARRAY') {
      if (@{ $_[0] } &gt; 3 &amp;&amp; $_[0]-&gt;[3] =~ /\d$/) {
         $_begin = $_[0]-&gt;[0], $_end = $_[0]-&gt;[-1];
         $_params-&gt;{$_pid}{sequence} = [ $_[0]-&gt;[0], $_[0]-&gt;[-1] ];
      }
      else {
         $_begin = $_[0]-&gt;[0], $_end = $_[0]-&gt;[1];
         $_params-&gt;{$_pid}{sequence} = $_[0];
      }
   }
   elsif (ref $_[0] eq '' || ref($_[0]) =~ /^Math::/) {
      if (@_ &gt; 3 &amp;&amp; $_[3] =~ /\d$/) {
         $_begin = $_[0], $_end = $_[-1];
         $_params-&gt;{$_pid}{sequence} = [ $_[0], $_[-1] ];
      }
      else {
         $_begin = $_[0], $_end = $_[1];
         $_params-&gt;{$_pid}{sequence} = [ @_ ];
      }
   }
   else {
      _croak(&quot;$_tag: (sequence) is not specified or valid&quot;);
   }

   _croak(&quot;$_tag: (begin) is not specified for sequence&quot;)
      unless (defined $_begin);
   _croak(&quot;$_tag: (end) is not specified for sequence&quot;)
      unless (defined $_end);

   $_params-&gt;{$_pid}{sequence_run} = undef;

   @_ = ();

   return run($_code);
}

###############################################################################
## ----------------------------------------------------------------------------
## Parallel grep with MCE.
##
###############################################################################

sub run (&amp;@) {

   shift if (defined $_[0] &amp;&amp; $_[0] eq 'MCE::Grep');

   my $_code = shift;  $_total_chunks = 0; undef %_tmp;
   my $_pkg  = caller() eq 'MCE::Grep' ? caller(1) : caller();
   my $_pid  = &quot;$$.$_tid.$_pkg&quot;;

   my $_input_data; my $_max_workers = $_def-&gt;{$_pkg}{MAX_WORKERS};
   my $_r = ref $_[0];

   if (@_ == 1 &amp;&amp; $_r =~ /^(?:ARRAY|HASH|SCALAR|CODE|GLOB|FileHandle|IO::)/) {
      _croak(&quot;$_tag: (HASH) not allowed as input by this MCE model&quot;)
         if $_r eq 'HASH';
      $_input_data = shift;
   }

   if (defined (my $_p = $_params-&gt;{$_pid})) {
      $_max_workers = MCE::_parse_max_workers($_p-&gt;{max_workers})
         if (exists $_p-&gt;{max_workers});

      delete $_p-&gt;{sequence}    if (defined $_input_data || scalar @_);
      delete $_p-&gt;{user_func}   if (exists $_p-&gt;{user_func});
      delete $_p-&gt;{user_tasks}  if (exists $_p-&gt;{user_tasks});
      delete $_p-&gt;{use_slurpio} if (exists $_p-&gt;{use_slurpio});
      delete $_p-&gt;{bounds_only} if (exists $_p-&gt;{bounds_only});
      delete $_p-&gt;{gather}      if (exists $_p-&gt;{gather});
   }

   my $_chunk_size = do {
      my $_p = $_params-&gt;{$_pid} || {};
      (defined $_p-&gt;{init_relay} || defined $_def-&gt;{$_pkg}{INIT_RELAY}) ? 1 :
      MCE::_parse_chunk_size(
         $_def-&gt;{$_pkg}{CHUNK_SIZE}, $_max_workers, $_params-&gt;{$_pid},
         $_input_data, scalar @_
      );
   };

   if (defined (my $_p = $_params-&gt;{$_pid})) {
      if (exists $_p-&gt;{_file}) {
         $_input_data = delete $_p-&gt;{_file};
      } else {
         $_input_data = $_p-&gt;{input_data} if exists $_p-&gt;{input_data};
      }
   }

   ## -------------------------------------------------------------------------

   MCE::_save_state($_MCE-&gt;{$_pid});

   if (!defined $_prev_c-&gt;{$_pid} || $_prev_c-&gt;{$_pid} != $_code) {
      $_MCE-&gt;{$_pid}-&gt;shutdown() if (defined $_MCE-&gt;{$_pid});
      $_prev_c-&gt;{$_pid} = $_code;

      my %_opts = (
         max_workers =&gt; $_max_workers, task_name =&gt; $_tag,
         user_func =&gt; sub {

            my ($_mce, $_chunk_ref, $_chunk_id) = @_;
            my $_wantarray = $_mce-&gt;{user_args}[0];

            if ($_wantarray) {
               my @_a;

               if (ref $_chunk_ref eq 'SCALAR') {
                  local $/ = $_mce-&gt;{RS} if defined $_mce-&gt;{RS};
                  open my $_MEM_FH, '&lt;', $_chunk_ref;
                  binmode $_MEM_FH, ':raw';
                  while (&lt;$_MEM_FH&gt;) { push (@_a, $_) if &amp;{ $_code }; }
                  close   $_MEM_FH;
                  weaken  $_MEM_FH;
               }
               else {
                  if (ref $_chunk_ref) {
                     push @_a, grep { &amp;{ $_code } } @{ $_chunk_ref };
                  } else {
                     push @_a, grep { &amp;{ $_code } } $_chunk_ref;
                  }
               }

               MCE-&gt;gather($_chunk_id, \@_a);
            }
            else {
               my $_cnt = 0;

               if (ref $_chunk_ref eq 'SCALAR') {
                  local $/ = $_mce-&gt;{RS} if defined $_mce-&gt;{RS};
                  open my $_MEM_FH, '&lt;', $_chunk_ref;
                  binmode $_MEM_FH, ':raw';
                  while (&lt;$_MEM_FH&gt;) { $_cnt++ if &amp;{ $_code }; }
                  close   $_MEM_FH;
                  weaken  $_MEM_FH;
               }
               else {
                  if (ref $_chunk_ref) {
                     $_cnt += grep { &amp;{ $_code } } @{ $_chunk_ref };
                  } else {
                     $_cnt += grep { &amp;{ $_code } } $_chunk_ref;
                  }
               }

               MCE-&gt;gather($_cnt) if defined $_wantarray;
            }
         },
      );

      if (defined (my $_p = $_params-&gt;{$_pid})) {
         for my $_k (keys %{ $_p }) {
            next if ($_k eq 'sequence_run');
            next if ($_k eq 'input_data');
            next if ($_k eq 'chunk_size');

            _croak(&quot;$_tag: ($_k) is not a valid constructor argument&quot;)
               unless (exists $MCE::_valid_fields_new{$_k});

            $_opts{$_k} = $_p-&gt;{$_k};
         }
      }

      for my $_k (qw/ tmp_dir freeze thaw init_relay use_threads /) {
         $_opts{$_k} = $_def-&gt;{$_pkg}{uc($_k)}
            if (exists $_def-&gt;{$_pkg}{uc($_k)} &amp;&amp; !exists $_opts{$_k});
      }

      $_MCE-&gt;{$_pid} = MCE-&gt;new(pkg =&gt; $_pkg, %_opts);
   }

   ## -------------------------------------------------------------------------

   my $_cnt = 0; my $_wantarray = wantarray;

   $_MCE-&gt;{$_pid}{use_slurpio} = ($_chunk_size &gt; &amp;MCE::MAX_RECS_SIZE) ? 1 : 0;
   $_MCE-&gt;{$_pid}{user_args}   = [ $_wantarray ];

   $_MCE-&gt;{$_pid}{gather} = $_wantarray
      ? \&amp;_gather : sub { $_cnt += $_[0]; return; };

   if (defined $_input_data) {
      @_ = ();
      $_MCE-&gt;{$_pid}-&gt;process({ chunk_size =&gt; $_chunk_size }, $_input_data);
      delete $_MCE-&gt;{$_pid}{input_data};
   }
   elsif (scalar @_) {
      $_MCE-&gt;{$_pid}-&gt;process({ chunk_size =&gt; $_chunk_size }, \@_);
      delete $_MCE-&gt;{$_pid}{input_data};
   }
   else {
      if (defined $_params-&gt;{$_pid} &amp;&amp; exists $_params-&gt;{$_pid}{sequence}) {
         $_MCE-&gt;{$_pid}-&gt;run({
             chunk_size =&gt; $_chunk_size,
             sequence   =&gt; $_params-&gt;{$_pid}{sequence}
         }, 0);
         if (exists $_params-&gt;{$_pid}{sequence_run}) {
             delete $_params-&gt;{$_pid}{sequence_run};
             delete $_params-&gt;{$_pid}{sequence};
         }
         delete $_MCE-&gt;{$_pid}{sequence};
      }
   }

   MCE::_restore_state();

   if ($_wantarray) {
      return map { @{ $_ } } delete @_tmp{ 1 .. $_total_chunks };
   }
   elsif (defined $_wantarray) {
      return $_cnt;
   }

   return;
}

###############################################################################
## ----------------------------------------------------------------------------
## Private methods.
##
###############################################################################

sub _croak {

   goto &amp;MCE::_croak;
}

1;

__END__

###############################################################################
## ----------------------------------------------------------------------------
## Module usage.
##
###############################################################################

=head1 NAME

MCE::Grep - Parallel grep model similar to the native grep function

=head1 VERSION

This document describes MCE::Grep version 1.901

=head1 SYNOPSIS

 ## Exports mce_grep, mce_grep_f, and mce_grep_s
 use MCE::Grep;

 ## Array or array_ref
 my @a = mce_grep { $_ % 5 == 0 } 1..10000;
 my @b = mce_grep { $_ % 5 == 0 } \@list;

 ## Important; pass an array_ref for deeply input data
 my @c = mce_grep { $_-&gt;[1] % 2 == 0 } [ [ 0, 1 ], [ 0, 2 ], ... ];
 my @d = mce_grep { $_-&gt;[1] % 2 == 0 } \@deeply_list;

 ## File path, glob ref, IO::All::{ File, Pipe, STDIO } obj, or scalar ref
 ## Workers read directly and not involve the manager process
 my @e = mce_grep_f { /pattern/ } &quot;/path/to/file&quot;; # efficient

 ## Involves the manager process, therefore slower
 my @f = mce_grep_f { /pattern/ } $file_handle;
 my @g = mce_grep_f { /pattern/ } $io;
 my @h = mce_grep_f { /pattern/ } \$scalar;

 ## Sequence of numbers (begin, end [, step, format])
 my @i = mce_grep_s { %_ * 3 == 0 } 1, 10000, 5;
 my @j = mce_grep_s { %_ * 3 == 0 } [ 1, 10000, 5 ];

 my @k = mce_grep_s { %_ * 3 == 0 } {
    begin =&gt; 1, end =&gt; 10000, step =&gt; 5, format =&gt; undef
 };

=head1 DESCRIPTION

This module provides a parallel grep implementation via Many-Core Engine.
MCE incurs a small overhead due to passing of data. A fast code block will
run faster natively. However, the overhead will likely diminish as the
complexity increases for the code.

 my @m1 =     grep { $_ % 5 == 0 } 1..1000000;          ## 0.065 secs
 my @m2 = mce_grep { $_ % 5 == 0 } 1..1000000;          ## 0.194 secs

Chunking, enabled by default, greatly reduces the overhead behind the scene.
The time for mce_grep below also includes the time for data exchanges between
the manager and worker processes. More parallelization will be seen when the
code incurs additional CPU time.

 my @m1 =     grep { /[2357][1468][9]/ } 1..1000000;    ## 0.353 secs
 my @m2 = mce_grep { /[2357][1468][9]/ } 1..1000000;    ## 0.218 secs

Even faster is mce_grep_s; useful when input data is a range of numbers.
Workers generate sequences mathematically among themselves without any
interaction from the manager process. Two arguments are required for
mce_grep_s (begin, end). Step defaults to 1 if begin is smaller than end,
otherwise -1.

 my @m3 = mce_grep_s { /[2357][1468][9]/ } 1, 1000000;  ## 0.165 secs

Although this document is about MCE::Grep, the L&lt;MCE::Stream&gt; module can write
results immediately without waiting for all chunks to complete. This is made
possible by passing the reference to an array (in this case @m4 and @m5).

 use MCE::Stream default_mode =&gt; 'grep';

 my @m4; mce_stream \@m4, sub { /[2357][1468][9]/ }, 1..1000000;

    ## Completed in 0.203 secs. This is amazing considering the
    ## overhead for passing data between the manager and workers.

 my @m5; mce_stream_s \@m5, sub { /[2357][1468][9]/ }, 1, 1000000;

    ## Completed in 0.120 secs. Like with mce_grep_s, specifying a
    ## sequence specification turns out to be faster due to lesser
    ## overhead for the manager process.

A common scenario is grepping for pattern(s) inside a massive log file.
Notice how parallelism increases as complexity increases for the pattern.
Testing was done against a 300 MB file containing 250k lines.

 use MCE::Grep;

 my @m; open my $LOG, &quot;&lt;&quot;, &quot;/path/to/log/file&quot; or die &quot;$!\n&quot;;

 @m = grep { /pattern/ } &lt;$LOG&gt;;                      ##  0.756 secs
 @m = grep { /foobar|[2357][1468][9]/ } &lt;$LOG&gt;;       ## 24.681 secs

 ## Parallelism with mce_grep. This involves the manager process
 ## due to processing a file handle.

 @m = mce_grep { /pattern/ } &lt;$LOG&gt;;                  ##  0.997 secs
 @m = mce_grep { /foobar|[2357][1468][9]/ } &lt;$LOG&gt;;   ##  7.439 secs

 ## Even faster with mce_grep_f. Workers access the file directly
 ## with zero interaction from the manager process.

 my $LOG = &quot;/path/to/file&quot;;
 @m = mce_grep_f { /pattern/ } $LOG;                  ##  0.112 secs
 @m = mce_grep_f { /foobar|[2357][1468][9]/ } $LOG;   ##  6.840 secs

=head1 PARSING HUGE FILES

The MCE::Grep module lacks an optimization for quickly determining if a match
is found from not knowing the pattern inside the code block. Use the following
snippet as a template to achieve better performance. Also, take a look at
examples/egrep.pl, included with the distribution.

 use MCE::Loop;

 MCE::Loop-&gt;init(
    max_workers =&gt; 8, use_slurpio =&gt; 1
 );

 my $pattern  = 'karl';
 my $hugefile = 'very_huge.file';

 my @result = mce_loop_f {
    my ($mce, $slurp_ref, $chunk_id) = @_;

    ## Quickly determine if a match is found.
    ## Process slurped chunk only if true.

    if ($$slurp_ref =~ /$pattern/m) {
       my @matches;

       ## The following is fast on Unix. Performance degrades
       ## drastically on Windows beyond 4 workers.

       open my $MEM_FH, '&lt;', $slurp_ref;
       binmode $MEM_FH, ':raw';
       while (&lt;$MEM_FH&gt;) { push @matches, $_ if (/$pattern/); }
       close   $MEM_FH;

       ## Therefore, use the following construct on Windows.

       while ( $$slurp_ref =~ /([^\n]+\n)/mg ) {
          my $line = $1; # save $1 to not lose the value
          push @matches, $line if ($line =~ /$pattern/);
       }

       ## Gather matched lines.

       MCE-&gt;gather(@matches);
    }

 } $hugefile;

 print join('', @result);

=head1 OVERRIDING DEFAULTS

The following list options which may be overridden when loading the module.

 use Sereal qw( encode_sereal decode_sereal );
 use CBOR::XS qw( encode_cbor decode_cbor );
 use JSON::XS qw( encode_json decode_json );

 use MCE::Grep
     max_workers =&gt; 4,                # Default 'auto'
     chunk_size =&gt; 100,               # Default 'auto'
     tmp_dir =&gt; &quot;/path/to/app/tmp&quot;,   # $MCE::Signal::tmp_dir
     freeze =&gt; \&amp;encode_sereal,       # \&amp;Storable::freeze
     thaw =&gt; \&amp;decode_sereal,         # \&amp;Storable::thaw
     init_relay =&gt; 0,                 # Default undef; MCE 1.882+
     use_threads =&gt; 0,                # Default undef; MCE 1.882+
 ;

From MCE 1.8 onwards, Sereal 3.015+ is loaded automatically if available.
Specify C&lt;&lt; Sereal =&gt; 0 &gt;&gt; to use Storable instead.

 use MCE::Grep Sereal =&gt; 0;

=head1 CUSTOMIZING MCE

=over 3

=item MCE::Grep-&gt;init ( options )

=item MCE::Grep::init { options }

=back

The init function accepts a hash of MCE options. The gather option, if
specified, is ignored due to being used internally by the module.

In scalar context (API available since 1.897), call C&lt;MCE::Grep-&gt;finish&gt;
automatically upon leaving the scope or program.

 use MCE::Grep;

 my $guard = MCE::Grep-&gt;init(
    chunk_size =&gt; 1, max_workers =&gt; 4,

    user_begin =&gt; sub {
       print &quot;## &quot;, MCE-&gt;wid, &quot; started\n&quot;;
    },

    user_end =&gt; sub {
       print &quot;## &quot;, MCE-&gt;wid, &quot; completed\n&quot;;
    }
 );

 my @a = mce_grep { $_ % 5 == 0 } 1..100;

 print &quot;\n&quot;, &quot;@a&quot;, &quot;\n&quot;;

 -- Output

 ## 2 started
 ## 3 started
 ## 1 started
 ## 4 started
 ## 3 completed
 ## 4 completed
 ## 1 completed
 ## 2 completed

 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100

=head1 API DOCUMENTATION

=over 3

=item MCE::Grep-&gt;run ( sub { code }, list )

=item mce_grep { code } list

=back

Input data may be defined using a list or an array reference. Unlike MCE::Loop,
Flow, and Step, specifying a hash reference as input data isn't allowed.

 ## Array or array_ref
 my @a = mce_grep { /[2357]/ } 1..1000;
 my @b = mce_grep { /[2357]/ } \@list;

 ## Important; pass an array_ref for deeply input data
 my @c = mce_grep { $_-&gt;[1] =~ /[2357]/ } [ [ 0, 1 ], [ 0, 2 ], ... ];
 my @d = mce_grep { $_-&gt;[1] =~ /[2357]/ } \@deeply_list;

 ## Not supported
 my @z = mce_grep { ... } \%hash;

=over 3

=item MCE::Grep-&gt;run_file ( sub { code }, file )

=item mce_grep_f { code } file

=back

The fastest of these is the /path/to/file. Workers communicate the next offset
position among themselves with zero interaction by the manager process.

C&lt;IO::All&gt; { File, Pipe, STDIO } is supported since MCE 1.845.

 my @c = mce_grep_f { /pattern/ } &quot;/path/to/file&quot;;  # faster
 my @d = mce_grep_f { /pattern/ } $file_handle;
 my @e = mce_grep_f { /pattern/ } $io;              # IO::All
 my @f = mce_grep_f { /pattern/ } \$scalar;

=over 3

=item MCE::Grep-&gt;run_seq ( sub { code }, $beg, $end [, $step, $fmt ] )

=item mce_grep_s { code } $beg, $end [, $step, $fmt ]

=back

Sequence may be defined as a list, an array reference, or a hash reference.
The functions require both begin and end values to run. Step and format are
optional. The format is passed to sprintf (% may be omitted below).

 my ($beg, $end, $step, $fmt) = (10, 20, 0.1, &quot;%4.1f&quot;);

 my @f = mce_grep_s { /[1234]\.[5678]/ } $beg, $end, $step, $fmt;
 my @g = mce_grep_s { /[1234]\.[5678]/ } [ $beg, $end, $step, $fmt ];

 my @h = mce_grep_s { /[1234]\.[5678]/ } {
    begin =&gt; $beg, end =&gt; $end,
    step =&gt; $step, format =&gt; $fmt
 };

=over 3

=item MCE::Grep-&gt;run ( sub { code }, iterator )

=item mce_grep { code } iterator

=back

An iterator reference may be specified for input_data. Iterators are described
under section &quot;SYNTAX for INPUT_DATA&quot; at L&lt;MCE::Core&gt;.

 my @a = mce_grep { $_ % 3 == 0 } make_iterator(10, 30, 2);

=head1 MANUAL SHUTDOWN

=over 3

=item MCE::Grep-&gt;finish

=item MCE::Grep::finish

=back

Workers remain persistent as much as possible after running. Shutdown occurs
automatically when the script terminates. Call finish when workers are no
longer needed.

 use MCE::Grep;

 MCE::Grep-&gt;init(
    chunk_size =&gt; 20, max_workers =&gt; 'auto'
 );

 my @a = mce_grep { ... } 1..100;

 MCE::Grep-&gt;finish;

=head1 INDEX

L&lt;MCE|MCE&gt;, L&lt;MCE::Core&gt;

=head1 AUTHOR

Mario E. Roy, S&lt;E&lt;lt&gt;marioeroy AT gmail DOT comE&lt;gt&gt;&gt;

=cut

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fperl%2F542%2Fcpanel-lib%2FMCE'>Back to Directory</a>