On the basis of your description, Parallel::ForkManager might be appropriate.

You could DIY-it in a few lines of Perl using threads or fork very easily, but I think the above package is probably what you're looking for.

Here are couple of quick and dirty fork managers by 2 of the more illustrious monks.

#!/usr/bin/perl
#by merlyn
use POSIX ":sys_wait_h";

my @tasks = (1..398);
my %kids;

{
 while (@tasks and keys %kids < 5) {
   $kids{fork_a_task(shift @tasks)} = "active";
 }
 {
   my $pid = waitpid(-1, 0);
   if ($pid == -1) {
     %kids = ();
   } else {
     delete $kids{$pid};
   }
 }
 redo if @tasks or %kids;
}

sub fork_a_task {
 my $i = shift;
 my $pid = fork;
 return $pid if $pid;
 unless (defined $pid) {
   warn "cannot fork: $!";
   return 0;
 }
 ## do stuff for task $i goes here...
 print "Doing $i\n";
 exit 0;
}
[download]

#!/usr/bin/perl

#by Abigail of perlmonks.org
#Some times you have a need to fork of several children, but you want 
+to
#limit the maximum number of children that are alive at one time. Here
#are two little subroutines that might help you, mfork and afork. They
+ are very similar.
#They take three arguments,
#and differ in the first argument. For mfork, the first
#argument is a number, indicating how many children should be forked. 
+For
#afork, the first argument is an array - a child will be
#forked for each array element. The second argument indicates the maxi
+mum
#number of children that may be alive at one time. The third argument 
+is a
#code reference; this is the code that will be executed by the child. 
+One
#argument will be given to this code fragment; for mfork it will be an
+ increasing number,
#starting at one. Each next child gets the next number. For afork, the
+ array element is
#passed. Note that this code will assume no other children will be spa
+wned,
#and that $SIG {CHLD} hasn't been set to IGNORE.


mfork (10,10,\&hello);
sub hello{print "hello world\n";}

print "all done now\n";

###################################################
sub mfork ($$&) {
my ($count, $max, $code) = @_;
foreach my $c (1 .. $count) {
wait unless $c <= $max;
die "Fork failed: $!\n" unless defined (my $pid = fork);
exit $code -> ($c) unless $pid;
}
1 until -1 == wait;
}
##################################################
sub afork (\@$&) {
my ($data, $max, $code) = @_;
my $c = 0;
foreach my $data (@$data) {
wait unless ++ $c <= $max;
die "Fork failed: $!\n" unless defined (my $pid = fork);
exit $code -> ($data) unless $pid;
}
1 until -1 == wait;
}
#####################################################
[download]

These suggestions seem to be quite satisfactory.   Many thanks.

To answer the question of “scheduling:   “ at the moment, there isn’t any.”   The Perl program will simply launch n children and wait (sometimes hours) for any one of them to finish, then start the next one on a prescribed list (table).   (Stupidly simple, and absolutely essential.   Maybe someday it will get fancier, but then again, ts never was.)   This should “plug the leak in the dike,” and that’s the only thing I need The Camel to do now.   To replace an unreliable, unknown utility with a reliable beast of burden (having a large, friendly humph).