This sounds like a job for POE, but I don't know enough about that module to say for sure.

If I were writing this, I'd be strongly tempted to make each child into an object. You could stash within it $params and all the other state that you're trying to hold and modularize all the behavior you want them to have. Each child object in the parent would know the PID of the child process, the parameters it started with, how many times it has died, etc.

• Give the child object a DESTROY method that kills the child process. This way when the parent exits, the children go with it.
• The parent can still wait for something to die and tell the relevant child to restart itself.
• The child can fork and then sleep to get the delay you want.

Something like:

my @child_info;
foreach my $params (@params_for_children)
{
    my $child = Foo::Child->new( params => $params );
    $child->spawn();
    push @child_info, $child;
}

while ( my $pid = wait() ) 
{
    last if $pid = -1;
    my $exit_status = $?;
    my ($poor_dead_child)
        = grep { $_->{pid} == $pid } @child_info;
    $poor_dead_child->fyi_you_died();
    $poor_dead_child->spawn();
}

package Foo::Child;

sub new {
    my $class = shift;
    my $self = { @_ };
    return bless $self, $class;
}

sub DESTROY { kill 'TERM' => shift->{pid} }

sub fyi_you_died { shift->{death_toll}++ }

sub spawn {
    my $self = shift;
    my $pid = fork;
    die "Can't fork: $!" if ! defined $pid;
    if ( $pid ) {
        $self->{pid} = $pid;
        return;
    }
    else {
         sleep ... if $self->{death_toll} > ...;
         do_child_stuff( $self->{params} );
         die;
    }
}
[download]

This is just a sketch, but hopefully you get the idea. Having written all this, I'm now guessing that someone will come along with a much better CPAN module I've never heard of.

Update: Upon further consideration, I'm not sure this is such a hot idea. Each child is a copy of the whole, so each has a copy of all the child objects. As soon as one of them dies, it's going to shoot all the other ones in their destructors. Oops. You could still have them all manage themselves except for the DESTROY methods. In that case, the parent would have to kill them all manually in an END {} block.

Update 2: Another thought. You could write DESTROY this way:

sub DESTROY {
    my $self = shift;
    if ( $$ == $self->{parent_pid} ) {
        kill 'TERM' => $self->{pid};
    }
}
[download]

Then you have spawn note the parent PID before it forks

sub spawn {
    my $self = shift;

    $self->{parent_pid} = $$;
    my $pid = fork;
# ...
[download]

---

---

Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!

Titles consisting of a single word are discouraged, and in most cases are disallowed outright.

Read Where should I post X? if you're not absolutely sure you're posting in the right place.

Please read these before you post! —

• How do I compose an effective node title?
• How do I post a question effectively?
• Markup in the Monastery

Posts may use any of the Perl Monks Approved HTML tags:

a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, details, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, summary, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr

You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)

	For:		Use:
	&		&
	<		&lt;
	>		&gt;
	[		&#91;
	]		&#93;

Link using PerlMonks shortcuts! What shortcuts can I use for linking?

See Writeup Formatting Tips and other pages linked from there for more info.