Update: Removing the shared hash code solves the hanging process problem, see below.

Unfortunately this, too, simply hangs on interrupt:

PID 28907
Forked worker in slot 2 with pid 28910 for chunk 1
Forked worker in slot 1 with pid 28909 for chunk 2
After 1: $VAR1 = {
          '00 28910' => '1491580974',
          '01 28909' => '1491580974'
        };

After 0: $VAR1 = {
          '00 28910' => '1491580974',
          '01 28909' => '1491580974'
        };

Forked worker in slot 1 with pid 28909 for chunk 3
Forked worker in slot 2 with pid 28910 for chunk 4
After 2: $VAR1 = {
          '00 28910' => '1491580974',
          '01 28909' => '1491580974',
          '02 28909' => '1491580975'
        };

After 3: $VAR1 = {
          '00 28910' => '1491580974',
          '01 28909' => '1491580974',
          '02 28909' => '1491580975',
          '03 28910' => '1491580975'
        };

^CHello from INT
Hello from INT
Hello from INT
[download]

pgr mce

nickt    28907       01:26 perl mce4.pl
nickt    28909       01:26 perl mce4.pl
nickt    28910       01:26 perl mce4.pl
[download]

I am running on Debian, Perl 5.16.3, with the very latest MCE modules.

Thank you.

Update: Note that if I simply comment out all the shared hash code, the program can be interrupted and the processes do not hang, but the END block is never reached:

perl mce4.pl

PID 29593
Forked worker in slot 2 with pid 29596 for chunk 1
Forked worker in slot 1 with pid 29595 for chunk 2
Forked worker in slot 1 with pid 29595 for chunk 4
Forked worker in slot 2 with pid 29596 for chunk 3
^CHello from INT
Worker is ready to dump
Hello from INT
Parent is ready to dump
Hello from INT
Worker is ready to dump

## mce4.pl: caught signal (INT), exiting

Killed
[download]

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

my $pid = $$; say "PID $pid";
my $mutex = MCE::Mutex->new();

#tie my %hash, 'MCE::Shared', ();

$SIG{'INT'} = sub {
    my $signal = shift;
    say 'Hello from INT';
#    if ( tied(%hash)->len ) {
        (MCE->wid == 0) ? say 'Parent is ready to dump'
                        : say 'Worker is ready to dump';

#        say 'Dumping: ' . Dumper \%hash;
#        %hash = ();
#    }
    MCE::Signal::stop_and_exit($signal);
};

$SIG{'TERM'} = sub {
    my $signal = shift;
    say 'Hello from TERM';
    if (MCE->wid > 0) { # worker
        MCE->exit(0);
    } else { # parent
        say 'Parent is ready to dump';
#        say 'Dumping: ' . Dumper \%hash;
        MCE::Signal::stop_and_exit($signal);
    }
};

MCE::Loop->init( max_workers => 2, chunk_size => 1 );

mce_loop {
    my ( $mce, $chunk_ref, $chunk_id ) = @_;
    say sprintf 'Forked worker in slot %s with pid %s for chunk %s', M
+CE->wid, MCE->pid, $chunk_id;
    for ( @{ $chunk_ref } ) {
#        $hash{ sprintf '%.2d %s', $_, $$ } = time;
        $mutex->synchronize( sub {
#           say "After $_: " . Dumper \%hash;
        });
        sleep 1;
    }
} ( 0 .. 4 );

MCE::Loop->finish;

END {
    say sprintf '%s %s (%s) in END', $$, time, $$ == $pid ? 'Parent' :
+ 'Child';
    if ( MCE->wid == 0 or $$ == $pid ) {
        say "Parent is ready to dump";
#        say 'Dumping: ' . Dumper \%hash;
    }
}
[download]

Yes, hangs when pressing Control-C.

Off topic, the OO interface is so nice. The mutex is not necessary. Btw, it is a bit much to have both the handlers and the END block. Only one is needed. But it still hangs when pressing Ctrl-C. However, sending INT from another terminal works fine. For this post, wanted to remove the TIE interface. Instead, access the shared hash via the OO interface. MCE::Shared can handle dereferencing automatically for setting the value. Thus, giving you both OO and dereferencing when needed.

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

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

$SIG{'INT'} = sub {
    my $signal = shift; $SIG{'INT'} = $SIG{'TERM'} = sub { };
    say "Hello from $signal: $$";
    if ( $hash->len ) {
        ( MCE->wid == 0 ) ? say 'Parent is ready to dump'
                          : say 'Worker is ready to dump';

        say 'Dumping: ' . Dumper $hash->export;
        $hash->clear;
    }

    MCE::Signal::stop_and_exit($signal);
};

$SIG{'TERM'} = sub {
    my $signal = shift; $SIG{'INT'} = $SIG{'TERM'} = sub { };
    say "Hello from $signal: $$";
    if (MCE->wid) { # worker
        MCE->exit(0);
    } else { # parent
        say 'Parent is ready to dump';
        say 'Dumping: ' . Dumper $hash->export;
        MCE::Signal::stop_and_exit($signal);
    }
};

MCE::Loop->init( max_workers => 2, chunk_size => 1 );

mce_loop {
    my ( $mce, $chunk_ref, $chunk_id ) = @_;
    say sprintf 'Forked worker in slot %s with pid %s for chunk %s', M
+CE->wid, MCE->pid, $chunk_id;
    for ( @{ $chunk_ref } ) {
        $hash->{ sprintf '%.2d %s', $_, $$ } = time;
        say "After $_: " . Dumper $hash->export;
        sleep 3;
    }
} ( 0 .. 12 );

MCE::Loop->finish;

say "Parent is ready to dump";
say 'Dumping: ' . Dumper $hash->export;
[download]

There is the main process, workers, and also the shared-manager process. Something is stalling somewhere.

The stall is happening from inside the handlers. Commenting out the hash->len and associated block inside the handlers resolves the stall. But then, we're back to square one in wanting to display the contents.

I'm on the road, my dad has fallen ill. I'm not myself lately. Am accepting that life is shorter each day. We only have little time with our parents. Your example is great. Signal handling is not fun. I do not understand why the END block isn't called. Will try setting the handlers to DEFAULT and other things including having the END block.

Thank you 1nickt for this test case.

Mario, please don't think about this for a moment longer now. You could not be more right about the preciousness of the time we have with our loved ones.

I see that you've also posted a more detailed reply to the root node, thank you. It's more than enough for now. After all I'm only dealing with an interrupt signal: your multiprocess engine and shared data structure are working perfectly. So, go now and do more important things :-)

Thank you,
-nick



The way forward always starts with a minimal test.