🚀 go-pugleaf

Ralph SOBEK wrote:
[snip]
>         What is the most efficient method to call a system routine
> repeatedly and capture it's short output?

If you *must* call it repeatedly, then you could probably start multiple
instances of the program simultaneously, with a pipe coming from each,
and after they're all started, read the pipes and collect the results.

>         Supposedly, in loop:
> 
> #1      system @cmd;
>
> is efficient.

It runs the command, sending the command's stdout to perl's stdout, and
having the command read from perl's stdin, and send's the command's
stderr to perl's stderr.  Since perl isn't doing the IO, it's reasonably
efficient.

>  But using backquotes:
> 
> #2      (my $sum = `@cmd 2>/dev/null`) =~ s/\s+.*$//;
> 
> captures the output correctly, but is horrendously slow,

First, this causes the command's stdout to be captured by perl.  Since
IO is slow, this isn't especially fast.

Second, due to needing the redirection, perl can't run the command
directly, but must instead start a shell, which parses the "2>..." part,
and *then* starts your program.

The extra step of starting a shell will of course slow things down.

> if repeated a couple of thousand times.  For 35,000 files count about
> SIX hours!
> 
>         Is there a possibility to prepare the fork in #1 in such a way
> as to recover the forks output afterwards?  It may help to know that
> the output consists only of two numbers.
> 
>         In fact, in the above I am using File::Find to recursively
> checksum a file structure.  @cmd[0] = '/usr/ucb/sum' and @cmd[1] is
> the file path.

Well, now that we know that you're running the 'sum' command, which will
take *multiple* file arguments on the commandline, if you ask it to, we
can suggest that collect bunches of filenames, then call 'sum' *once*
for that bunch.

That is, consider the speed difference between:
   find . -exec /usr/ucb/sum {} \;
And:
   find . | xargs /usr/ucb/sum

The first runs 'sum' once for each file.  The second collects bunches of
filenames, and runs 'sum' once for each bunch.

>         Furthermore, in #2 there is the additional problem that the
> shell causes with unusual file names.

Then don't invoke the shell, or don't let the filenames be seen by the
shell.

Consider this:
use IPC::Open3;
use File::Spec;
local (*DEVNULL, *FILENAMES, *CHECKSUMS);
open( DEVNULL, ">>", File::Spec->devnull )
   or die "Couldn't open /dev/null: $!";
open( FILENAMES, "-|", "find ." )
   or die "Couldn't spawn find process: $!";
my $sums = open3(
   "<&FILENAMES", \*CHECKSUMS, ">&DEVNULL",
   "xargs", "/usr/ucb/sum" );
while( <CHECKSUMS> ) {
   my ($crc, $size, $name) = split ' ', $_, 3;
   ... do stuff ...
}
waitpid( $sums, 0 ) or die horribly;
$? and die horribly;
__END__
[untested]

-- 
tr/`4/ /d, print "@{[map --$| ? ucfirst lc : lc, split]},\n" for
pack 'u', pack 'H*', 'ab5cf4021bafd28972030972b00a218eb9720000';