Given that nqp is faster then plain Perl 6 and threads combining the two should give us some decent speed. Using a Supply as promised in the last post wouldn’t really help. The emit will block until the internal queue of the Supply is cleared. If we want to process files recursively the filesystem might stall just after the recursing thread is unblocked. If we are putting pressure on the filesystem in the consumer, we are better of with a Channel that is swiftly filled with file paths.

Let’s start with a simulated consumer that will stall every now end then and takes the Channel in $c .

my @files;

react {

whenever $c -> $path {

@files.push: $path;

sleep 1 if rand < 0.00001;

}

}



If we would pump out paths as quickly as possible we could fill quite a bit of RAM and put a lot of pressure on the CPU caches. After some trial and error I found that sleeping befor the .send on the Channel helps when there are more then 64 worker threads waiting to be put onto machine threads. That information is accessible via Telemetry::Instrument::ThreadPool::Snap.new<gtq> .



my $c = Channel.new;

start {

my @dirs = '/snapshots/home-2019-01-29';

while @dirs.shift -> str $dir {

my Mu $dirh := nqp::opendir(nqp::unbox_s($dir));

while my str $name = nqp::nextfiledir($dirh) {

next if $name eq '.' | '..';

my str $abs-path = nqp::concat( nqp::concat($dir, '/'), $name);

next if nqp::fileislink($abs-path);

if Telemetry::Instrument::ThreadPool::Snap.new<gtq> > 64 {

say Telemetry::Instrument::ThreadPool::Snap.new<gtq>;

say 'sleeping';

sleep 0.1;

}

$c.send($abs-path) if nqp::stat($abs-path, nqp::const::STAT_ISREG);

@dirs.push: $abs-path if nqp::stat($abs-path, nqp::const::STAT_ISDIR);

}

CATCH { default { put BOLD .Str, ' ⟨', $dir, '⟩' } }

nqp::closedir($dirh); }

$c.close;

}



Sleeping for 0.1s before sending the next value is a bit naive. It would be better to watch the number of waiting workers and only continue when it has dropped below 64. But that is a task for a differnt module. We don’t really have a middle ground in Perl 6 between Supply with it’s blocking nature and the value pumping Channel. So such a module might be actually quite useful.

But that will have to wait. I seam to have stepped on a bug in IO::Handle.read while working with large binary files. We got tons of tests on roast that deal with small data. Working with large data isn’t well tested and I wonder what monsters are lurking there.