EXPORT

EXPORT_OK

FUNCTIONS

size(), size($number)

If an argument is given the maximun number of concurrent processes is set to it and the number of maximun processes that were allowed before is returned.

If no argument is given, the number of processes allowed is returned.

delay(), delay($time)

lets you set a minimun time in seconds to elapse between consecutive calls to fork. It is useful to avoid creating too many processes in a short time (that could degrade performance).

If Time::HiRes module is available delays shorted that 1 second are allowed.

If no arg is given, the current delay is returned.

To clear it use Proc::Queue::delay(0).

weight(), weight($weight)

by default any process forked count as 1 through the max number of processes allowed to run simultaneously (the queue size). "weight" allows to change this, i.e.:

  Proc::Queue::weight(3);
  run_back { ... heavy process here ... };
  Proc::Queue::weight(1);
    

causes the "heavy process" to count as three normal processes.

Valid weight values are integers greater than zero.

Remember to reset the weight back to 1 (or whatever) after the heavier processes have been forked!.

allow_excess(), allow_excess($allow_excess)

by default the next queued process will be started as soon as the number of running processes is smaller than the queue size--this is regardless of the weight of the next queued process, so the queue could become overloaded. Setting "allow_excess" to false forces the next queued process to wait until there is room for it in the queue, that is, the size of the queue less the weighted number of currently running processes must be no smaller than the weight of the next queued process in order for the next process to start.

Setting "allow_excess" to any value greater than zero (default is 1) resets the default behavior.

ignore_children($on)

calling

  Proc::Queue::ignore_children(1);
    

is the equivalent to

  $SIG{CHLD}='IGNORE'
    

when using Proc::Queue.

debug(), debug($boolean), trace(), trace($boolean)

Change or return the status for the debug and trace modes.

Other utility subroutines that can be imported from Proc::Queue are:

fork_now()

Sometimes you would need to fork a new child without waiting for other children to exit if the queue is full, "fork_now" does that. It is exportable so you can do...

  use Proc::Queue size => 5, qw(fork_now), debug =>1;

  $f=fork_now;
  if(defined $f and $f == 0) {
      print "I'm the child\n"; exit;
  }
    

waitpids(@pid)

waits for all the processes in @pid to exit. It returns an array with pairs of pid and exit values (pid1, exit1, pid2, exit2, pid3, exit3,...) as returned by individual waitpid calls.

run_back(\&code), run_back { code }

Runs the argument subrutine in a forked child process and returns the pid number for the new process.

run_back_now(\&code), run_back_now { code }

A mix between run_back and fork_now.

system_back(@command)

Similar to the "system" call but runs the command in the background and waits for other children to exit first if there are already too many running.

Returns the pid of the forked process or undef if the program was not found.

system_back_now(@command)

As "system_back" but without checking if the maximun number of children allowed has been reached.

all_exit_ok(@pid)

Do a "waitpids" call and test that all the processes exit with code 0.

running_now()

Returns the number of child processes currently running.

import(pkg,opt,val,opt,val,...,fnt_name,fnt_name,...)

The import function is not usually explicitally called but by the "use Proc::Queue" statement.

Options allowed are "size", "debug", "weight" and "trace", i.e:

  use Proc::Queue size=>10, debug=>1;
    

Anything that is not "size", "debug", "weight" or "trace" is expected to be a function name to be imported.

  use Proc::Queue size=>10, ':all';
    

BUGS

Support for Win32 OSs is still experimental.