Greetings vr,

Cool gradient background! I tried adding frames simultaneously while running by modifying the gather code block.

  gather      => sub {
    if (@_ == 1) {
      print "\r", $count++;
    }
    else {
      if (!defined $gifdata) {
        $image    = GD::Image-> newFromGifData( shift @{ $_[1] } );
        $gifdata  = $image-> gifanimbegin( 0,0 );
        $gifdata .= $image-> gifanimadd( 1,0,0,1,1 );
      }
      while ( my $data = shift @{ $_[1] } ) {
        my $frame = GD::Image-> newFromGifData( $data );
        $gifdata .= $frame-> gifanimadd( 1,0,0,1,1 );
      }
    }
  },
[download]

That results in workers waiting for the manager process which is fine (i.e. the manager process is now the bottleneck). In that case chunk_size 1 may be faster to have the manager process quickly add one frame. Thereby able to respond to other workers with lesser latency.

use strict;
use warnings;
use feature 'say';
use Imager;
use MCE::Loop;
use Time::HiRes 'time';
use GD;

STDOUT->autoflush;

my $start = time;
my $count = 0;

my $bkg;
my $image;
my $gifdata;

MCE::Loop->init(
  max_workers => MCE::Util::get_ncpu(),
  chunk_size  => 1,
  init_relay  => '',

  gather      => sub {
    if (@_ == 1) {
      print "\r", $count++;
    }
    else {
      if (!defined $gifdata) {
        $image    = GD::Image-> newFromGifData( shift @{ $_[1] } );
        $gifdata  = $image-> gifanimbegin( 0,0 );
        $gifdata .= $image-> gifanimadd( 1,0,0,1,1 );
      }
      while ( my $data = shift @{ $_[1] } ) {
        my $frame = GD::Image-> newFromGifData( $data );
        $gifdata .= $frame-> gifanimadd( 1,0,0,1,1 );
      }
    }
  },

  user_begin => sub {
    $bkg = Imager->new(xsize=>800, ysize=>600);
    $bkg->filter(type=>"gradgen",
                 xo=>[ 100, 300, 600 ],
                 yo=>[ 100, 300, 100 ],
                 colors=>[ qw(red blue green) ]);
    $bkg->filter(type=>"noise", amount=>12, subtype=>0)
  },
);

mce_loop {
  my ($mce, $chunk_ref, $chunk_id) = @_;
  my @i_data;

  for my $x (@{ $chunk_ref }) {
    my $i = $bkg-> copy;

    $i->string(
      text  => $x,
      color => Imager::Color->new('ffffff'),
      font  => Imager::Font->new(
      # file  => '/usr/share/fonts/truetype/msttcorefonts/cour.ttf', #
+ Ubuntu
      # file  => '/System/Library/Fonts/Courier.dfont',
        face  => 'Courier New', # mswin
        size  => 420,
        aa    => 1),
      x     => 25,
      y     => 500,
    );

    $i->write(data => \my $data, type => 'gif');
    push @i_data, $data;

    MCE->gather($x);
  }

  MCE::relay { MCE->gather($chunk_id, \@i_data) };

} [ 0 .. 319 ];

MCE::Loop->finish;

print " frame GIF done!\n";
printf "compute time: %0.3fs\n", time - $start;

$gifdata .= $image-> gifanimend;

open my $fh, '>:raw', 'gd.gif';
print $fh $gifdata;
close $fh;

printf "Total: %0.3fs\n", time - $start;
[download]

Regards, Mario

MCE::Channel is included in recent MCE releases. MCE::Flow allows running multiple tasks simultaneously.

So here is a great demonstration for MCE::Flow and MCE::Channel. The benefit is that the manager process does little work and better able to accommodate workers requesting input with minimum latency. The bottleneck is now the gifout task which is a separate worker. Notice user_begin and user_end called for the first task only by checking MCE->task_id. Notice also max_workers taking an array ref for specifying how many workers for each task.

The following demonstration was made possible by PerlMonks. Thanks vr for providing GD tips. Thank you Anonymous Monk for posting.

use strict;
use warnings;
use feature 'say';
use Imager;
use MCE::Flow;
use MCE::Channel;
use Time::HiRes 'time';
use GD;

STDOUT->autoflush;

my $start = time;
my $chnl  = MCE::Channel->new();
my $count = 0;
my $bkg;

MCE::Flow->init(
  max_workers => [ MCE::Util::get_ncpu() - 1, 1 ],
  chunk_size  => 1,
  init_relay  => '',
  gather      => sub {
      print "\r", $count++;
  },
  user_begin => sub {
    if (MCE->task_id == 0) {
      $bkg = Imager->new(xsize=>800, ysize=>600);
      $bkg->filter(type=>"gradgen",
                   xo=>[ 100, 300, 600 ],
                   yo=>[ 100, 300, 100 ],
                   colors=>[ qw(red blue green) ]);
      $bkg->filter(type=>"noise", amount=>12, subtype=>0)
    }
  },
  user_end => sub {
    if (MCE->task_id == 0) {
      $chnl->end;
    }
  }
);

sub task_frames {
  my ($mce, $chunk_ref, $chunk_id) = @_;
  my @i_data;

  for my $x (@{ $chunk_ref }) {
    my $i = $bkg-> copy;

    $i->string(
      text  => $x,
      color => Imager::Color->new('ffffff'),
      font  => Imager::Font->new(
      # file  => '/usr/share/fonts/truetype/msttcorefonts/cour.ttf', #
+ Ubuntu
      # file  => '/System/Library/Fonts/Courier.dfont',
        face  => 'Courier New', # mswin
        size  => 420,
        aa    => 1),
      x     => 25,
      y     => 500,
    );

    $i->write(data => \my $data, type => 'gif');
    push @i_data, $data;

    MCE->gather($x);
  }

  MCE::relay { $chnl->send(\@i_data) };
}

sub task_gifout {
  my $image;
  my $gifdata;

  while ( my $i_data_ref = $chnl->recv ) {
    if (!defined $gifdata) {
      $image    = GD::Image-> newFromGifData( shift @{ $i_data_ref } )
+;
      $gifdata  = $image-> gifanimbegin( 0,0 );
      $gifdata .= $image-> gifanimadd( 1,0,0,1,1 );
    }
    while ( my $data = shift @{ $i_data_ref } ) {
      my $frame = GD::Image-> newFromGifData( $data );
      $gifdata .= $frame-> gifanimadd( 1,0,0,1,1 );
    }
  }

  $gifdata .= $image-> gifanimend;

  open my $fh, '>:raw', 'gd.gif';
  print $fh $gifdata;
  close $fh;
}

mce_flow \&task_frames, \&task_gifout, [ 0 .. 319 ];

MCE::Flow->finish;

print " frame GIF done!\n";
printf "compute time: %0.3fs\n", time - $start;
[download]

There is a lot of parallel going on :) Although workers complete sooner, the manager process still waits for all tasks to finish before MCE::Flow exits.

Regards, Mario