my $pid;
[download]

While you can do what you'd like with your code, I'd personally move the child code into a separate subroutine and then have a big 'if ($fork)' at the beginning that called it in the fork loop and in the else clause, in order to keep the forking code as easy to read as possible -- YMMV.

Other than that, your code looks ok up until the wait() (i.e. you do need an explicit exit in the child code). You'll probably want to do your waiting outside of the forking loop, in a loop of it's own. You'll want to call wait() one time for each time you fork. Something like...

while ($childcnt > 0) {
    wait();
    $childcnt--;
}
[download]

FWIW, in your code if the fork fails you 'die' right away. I'd probably just report an error, drop out of the loop, wait for all of the children to die, and then die. Otherwise, your existing children will continue to run without a parent (perhaps you want it to do this?).

bluto

Wouldn't having a wait() inside the loop make the code execute as if it wasn't forking? consider this simplified version of your script:

## simplified code, so no error checking...
foreach my $node (@devices) {
   my $pid = fork();
   if( !$pid ) {
      ## child...
      exit 0;
   }
   ## parent
   wait();
}
[download]

So this means that for each node, you fork off a process, and immediately afterwards the parent waits for that process. The parent will block until the child is done. Thus no merit of forking here...

You need to do something like this:

use POSIX;
$SIG{CHLD} = sub {
    while( ( my $pid = waitpid(-1, POSIX::WNOHANG()) ) > 0 ){
        ## cleanup code...
        ## you probably should save the forked
        ## pids and make sure that the result of
        ## waitpid is indeed your child
    }
}

foreach my $nod ( @devices ) {
   my $pid = fork();
   if( !$pid ) {
      ## child...
   }
}
[download]

Now, as for your switching needs, I might do something like this:

use POSIX;
my $do_fork = 1;
$SIG{CHLD} = sub {
    while( ( my $pid = waitpid(-1, POSIX::WNOHANG()) ) > 0 ){
        ...
    }
}

foreach my $node ( @devices ) {
    if( $do_fork ) {
        my $pid = fork();
        if( !$pid ) {
            do_exciting_things();
            exit 0;
        }
    } else {
        do_exciting_things();
    }
}
[download]

This is obviously just a psuedocode, so make sure to put plenty more error checking and all that stuff.

Nice! Your last example of:

foreach my $node ( @devices ) {
    if( $do_fork ) {
        my $pid = fork();
        if( !$pid ) {
            do_exciting_things();
            exit 0;
        }
    } else {
        do_exciting_things();
    }
}
[download]

looks very much like my most recent rewrite after starting this thread, so i am very encouraged that I am actually starting to understand what it is you dudes actually are talking about :-)

maybe though you could clear up the fog for me on this:

use POSIX;
my $do_fork = 1;
$SIG{CHLD} = sub {
    while( ( my $pid = waitpid(-1, POSIX::WNOHANG()) ) > 0 ){
        ...
    }
}
[download]

this one has me scratching my head. if you'd rather point to a perldoc reference, i'm up for that as well. it looks as though you're defining a subroutine as a hash value, but i'm not certain where/how its being called.

thanks -c

Are you asking me about just the syntax? or about signal handling with %SIG ?

As far as the syntax goes, my code is equivalent to something like this:

   my $coderef = sub{ .... };
   ## now $coderef is a reference to a subroutine,
   ## which can be executed like this:
   ##
   ##    $coderef->(); # $coderef->( @args )
   ##

   $SIG{ CHLD }= $coderef;
[download]

So that means you can actually create an anonymous subroutine, and assign it to a scalar. Which in turn can be assigned to a hash value :)

As for the signal handling portion, perldoc perlipc will give you more information. Not sure what is the best resource for that... ( I could try to explain, but I'm not confident that my knowledge is 100% correct )