Oh, I hadn't thought of that, my slightly extended code was:

    $pid=open3($wtr, '>&reader', $err, $cmd);
    waitpid($pid, 0);

    my %Results=();
    while(<$rdr>){
        chomp;
        @temp=split(/\t/);
        if(!exists($Results{$temp[0]}) || $Results{$temp[0]}<$temp[10]
+){
            $Results{$temp[0]}=$temp[10];
        }
    }
[download]

So I take it that I should've used waitpid after I finished "reading" the pipe. Duh(!) Moving waitpid til after <$rdr> worked. Upon reflection, I realized that the output from running this particular file was far larger than any other, and was thus the first to fill the I/O buffer.

In related news, I gave myself a crash course in buffering and also tried using IPC::Run() with pty, and worked too, but which is recommended?

but which is recommended?

Well, it depends...

IPC::Open3 is an old module with an ugly interface and limited functionality. On the other hand you can rely on it being available mostly everywhere as it is distributed with Perl.

IPC::Run is a feature rich module and quite popular too. I find its API too complex, but that is probably the prize you pay for being feature rich!.

There is another alternative if you don't need your scripts to run on any OS other than Linux or Unix: to use the raw POSIX calls (fork, exec, dup2, etc.). In other words, doing it a-la 'C'.

In your particular case, where you are not sending any data to the child process, there is an even simpler solution: to use a single pipe. Perl provides native support for that via the open built-in:

my $pid = open my $rdr, "$cmd |" or die "unable to run external comman
+d: $!";

while (<$rdr>) {
   ...
}
close $rdr or die "reading from $rdr failed: $!";
[download]

Or even better, in order to avoid the shell (specially if it is the today infamous bash!), using the multi-argument open invocation:

my $pid = open my $rdr, '-|', $cmd, @args or die "unable to run extern
+al command: $!";

while (<$rdr>) {
   ...
}
close $rdr or die "reading from $rdr failed: $!";
[download]