You wait in the child instead of in the parent. You might want to look at something like Parallel::ForkManager to handle this kind of thing for you. Otherwise, the easiest thing to do is wait 16 times outside the loop to collect all the children.

You might also want to keep track of all the child PIDs so you can tell which you've reaped and which are still hanging around. If something is taking too long, it might be helpful to be able to kill it.

kyle is right - your call to wait is in the child and it should be in the parent. Actually, since it is right after the exec it will never get called under normal circumstances.

To spawn a new child process, use:

  die "unable to fork: $!" unless (defined(my $id = fork());
  if ($id == 0) {
    exec($testpath) or die "unable to exec $testpath: $!\n";
  }
[download]

and after the spawning loop, use:

while (wait > -1) {};
[download]

to wait for all of your children to terminate.

ok, I I added what you requested. However it still will continue the program and finish. I can pull up process on my linux and it shows the two instances of the chirp_md5sum program running.

$index=0;

my $inputfile="perloutput";
my $endfile=".txt ";
my $smb="> ";
my $outputfile="output";
my $smb2="&";

while ($index<2)
{
   my $testpath="chirp_md5sum ";
   $testpath=$testpath.$inputfile.$index.$endfile.$smb.$outputfile.$in
+dex.$endfile.$smb2;
   chomp $testpath;
   print ("$testpath \n");

   $id=fork();

   if ($id == 0) {
    exec($testpath) or die "unable to exec $testpath: $!\n";

  }

 $index++;
}

while (wait > -1) {};
[download]

Do you have a particular need to execute the 16 processes in parallel? If not, use system.

for (0..16) {
   my $idx = $_ || '';  # Don't actually include '0' in the file name.

   my $in_file  = "perloutput$idx.txt";
   my $out_file = "output$idx.txt";

   my $rv = system("chirp_md5sum $in_file > $out_file");

   die("Error launching child: $!\n")                    if $rv == -1;
   die(sprintf("Child died with signal %d\n", $rv & 127))if $rv & 127;
   die(sprintf("Child returned error %d\n, $rv >> 8))    if $rv;
}
[download]

But I'd also like to draw your attention to something not yet pointed out - you seem to believe that you can run code after calling exec(). That's incorrect - exec() replaces the process with a new one and never returns. Sometimes you'll see:

   exec(...) or die(...);

But that's just there to handle the possiblity that exec() might fail. If exec() succeeds then that process won't be running your code anymore.

-sam

#!/usr/bin/perl
use warnings;
use strict;

my %pids;

my @to_be_processed = (1..20);

my $cmd = 'echo';

foreach my $p (@to_be_processed){ 
   $pids{$p}{'pid'} = open($pids{$p}{'fh'}, "$cmd $p 2>&1 |");
}

# get output dosn't work? get globs
foreach my $key(keys %pids){ 
   while (<{ $pids{$key}{'fh'} }>){print $_}
}


foreach my $key(keys %pids){
   waitpid($pids{$key}, 1);
}

print "done\n";
[download]

The <> operator is super fussy due to being overloaded with ancient glob() craziness. It only works if you put in a simple scalar, not any kind of expression. This works:

  my $fh = $pids{$key}{'fh'};
  while (<$fh>){print $_}
[download]

This kind of thing will work fine until your sub-processes need to produce more than 4k of data (or whatever your buffer size is). Then the sub-procs will block when they print() and won't work in parallel while you're collecting results. To fix this you need to switch to using something like IO::Select or EV to pull data from each process as it's ready.

-sam

Calling close on the file handles will also wait for the processes to complete.

Where do you put the close for the file handlers?