Hello Mario,

(BTW you mentioned that having the signal handlers as well as END may be overdone ... the reason I have the data dumped in END is so it prints out upon uncaught exception.)

I made the change to MCE::Shared::Server as instructed. I took your last script (in the post I am replying to) and modified slightly. First, took some of the debug statements away and cleaned up others. Second, only dump the data in INT from parent process (as you have it in END). This gives following results:

With CTL-C, the END block is never reached by the parent; only the children. But the parent dumps the data in INT.

perl mce9.pl

Parent PID 11581
worker 2 (11584) processing chunk 1
worker 1 (11583) processing chunk 2
worker 1 (11583) processing chunk 4
worker 2 (11584) processing chunk 3
^CHello from INT: 11584
Hello from INT: 11581
Hello from END block: 11584
Parent in INT: $VAR1 = bless( {
                 '00 11584' => '1491592596',
                 '01 11583' => '1491592596',
                 '02 11584' => '1491592598',
                 '03 11583' => '1491592598'
               }, 'MCE::Shared::Hash' );


## mce9.pl: caught signal (INT), exiting
Hello from INT: 11583
Hello from END block: 11583

Killed
[download]

perl mce9.pl

Parent PID 11554
worker 2 (11557) processing chunk 1
worker 1 (11556) processing chunk 2
worker 2 (11557) processing chunk 3
worker 1 (11556) processing chunk 4
worker 1 (11556) processing chunk 6
worker 2 (11557) processing chunk 5
worker 1 (11556) processing chunk 7
Hello from END block: 11557
Hello from END block: 11556
Hello from END block: 11554
Parent in END: $VAR1 = bless( {
                 '00 11557' => '1491592580',
                 '01 11556' => '1491592580',
                 '02 11557' => '1491592582',
                 '03 11556' => '1491592582',
                 '04 11557' => '1491592584',
                 '05 11556' => '1491592584',
                 '06 11556' => '1491592586'
               }, 'MCE::Shared::Hash' );
[download]

Code now:

use strict; use warnings; use feature 'say';
use Data::Dumper; ++$Data::Dumper::Sortkeys;
use MCE::Loop;
use MCE::Shared;
$|++;

my $pid = $$; say "Parent PID $pid";
my $hash = MCE::Shared->hash();

$SIG{'INT'} = $SIG{'TERM'} = sub {
    my $signal = shift; $SIG{'INT'} = $SIG{'TERM'} = sub {};
    say "Hello from $signal: $$";
    if ( $$ == $pid ) {
        say 'Parent in INT: ' . Dumper $hash->export;
    }
    MCE::Signal::stop_and_exit('INT');
};

MCE::Loop->init(
    max_workers => 2, chunk_size => 1, user_begin => sub {
        $SIG{'INT'} = sub {
            my $signal = shift;
            say "Hello from $signal: $$";
            MCE->exit(0);
        };
        $SIG{'TERM'} = sub {
            my $signal = shift;
            say "Hello from $signal: $$";
            MCE::Signal::stop_and_exit($signal);
        };
    }
);

mce_loop {
    my ( $mce, $chunk_ref, $chunk_id ) = @_;
    say sprintf 'worker %s (%s) processing chunk %s', MCE->wid, MCE->p
+id, $chunk_id;
    for ( @{ $chunk_ref } ) {
        $hash->{ sprintf '%.2d %s', $_, $$ } = time;
        sleep 2;
    }
} ( 0 .. 6 );

MCE::Loop->finish;

END {
    say "Hello from END block: $$";
    if ( $$ == $pid ) {
        say 'Parent in END: ' . Dumper $hash->export;
    }
}
[download]

Thank you again.

Thanks 1nickt. Regarding the use of the END block, no problem and why not use it. MCE::Signal is the reason for why the END block is not called for the parent process. It ends up doing a KILL signal. Fortunately, one can disable that by loading MCE::Signal before other MCE modules and pass the -no_kill9 option. Now that the END block is working, the handlers for the parent process are no longer needed. Nor the TERM handler for MCE workers. The script now looks like this.

Regarding shared objects, having OO and auto-dereferencing on the fly makes it so natural versus calling tied(%hash)->method.

use strict; use warnings; use feature 'say';
use Data::Dumper; ++$Data::Dumper::Sortkeys;

use MCE::Signal qw( -no_kill9 );
use MCE::Loop;
use MCE::Shared;

$|++;

my $pid = $$; say "Parent PID $pid";
my $hash = MCE::Shared->hash();

MCE::Loop->init(
    max_workers => 2, chunk_size => 1, user_begin => sub {
        $SIG{'INT'} = sub {
            my $signal = shift;
            say "Hello from $signal: $$";
            MCE->exit(0);
        };
    }
);

mce_loop {
    my ( $mce, $chunk_ref, $chunk_id ) = @_;
    say sprintf 'worker %s (%s) processing chunk %s', MCE->wid, MCE->p
+id, $chunk_id;
    for ( @{ $chunk_ref } ) {
        $hash->{ sprintf '%.2d %s', $_, $$ } = time;
        sleep 2;
    }
} ( 0 .. 6 );

MCE::Loop->finish;

END {
    say "Hello from END block: $$";
    if ( $$ == $pid ) {
        say 'Parent in END: ' . Dumper $hash->export;
    }
}
[download]

I will test the change to MCE::Shared::Server. It's not feasible to handle both situations I'm not sure. However, it seems important for the shared-server to stick around longer to handle requests made inside handlers and END blocks.

sub _loop {
   $_is_client = 0;

 # $SIG{HUP} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub {
 #    $SIG{INT} = $SIG{$_[0]} = sub { };
 #
 #    CORE::kill($_[0], $_is_MSWin32 ? -$$ : -getpgrp);
 #    for my $_i (1..15) { sleep 0.060 }
 #
 #    CORE::kill('KILL', $$);
 #    CORE::exit(255);
 # };

   $SIG{HUP} = $SIG{INT} = $SIG{QUIT} = $SIG{TERM} = sub { };

   ...
}
[download]

It sure is nice to have the END block working. But it requires loading MCE::Signal qw( -no_kill9 ) before MCE modules to take effect. Signal handling is not fun. Likewise, parallel programming is crazy. But, with your help 1nickt, it's almost there.

We're on the road. Amazingly Wifi from the laptop via the phone is working well.

Thank you, 1nickt. Thank you, Perlmonks.

Am validating the change for _loop in MCE::Shared::Server. Also, in _stop (around line 370), need to comment out two lines. Otherwise, the shared-manager process may linger around as a zombie process.

sub _stop {
   return unless ($_is_client && $_init_pid && $_init_pid eq "$$.$_tid
+");

 # return if ($INC{'MCE/Signal.pm'} && $MCE::Signal::KILLED);
 # return if ($MCE::Shared::Server::KILLED);

   ...
}
[download]