A semaphore is basically an atomic counter. It guarantees that only one counter operation(increment or decrement) will occur no matter how many processes or threads are trying to operate on it simultaneously. Also, the counter may not be decremented lower than 0. Any attempt to decrement the counter when it is zero will 'block' , unless the IPC_NOWAIT flag is set on your operations, in which case it will fail with an errno set to EAGAIN or EWOULDBLOCK. The process will block until someone increments that semaphore. Once that happens if there is more than one process waiting to decrement it back to zero, only 1 will succeed.

Typically semaphores are used sort of like mutexes to prevent two processes from touching the same piece of shared memory at the same time.

However, your use for them is fine as well. The only thing is that you don't want to be incrementing it using getval setval. You want to use the 'op' method instead. Your code should look something this like this:

use IPC::SysV qw/SEM_UNDO IPC_CREAT ftok/ ;
use IPC::Semaphore ;



# start script
$flags = PERMISSIONS ;
$sem = new IPC::Semaphore(ftok($0, 0), 1, $flags) ;
unless($sem) {
   # we must be the first one
   $sem = new IPC::Semaphore($id, 1, $flags | IPC_CREAT)
   $sem->setval(0, 100) ;
}

##
## Decrement the #0 semaphore by 1
##
$sem->op(0, -1, SEM_UNDO) ; # blocks if semaphore is zero

#
# DO SCRIPT STUFF
# 


##
## Increment #0 semaphore by 1
##
$sem->op(0, 1, SEM_UNDO) ; 

# once past this point, any script waiting can proceed

# done
[download]

If I don't want the processes to block, then would the only changes I needed to make be in

• line 5, to include the symbols SEM_UNDO and ftok in the use IPC::SysV entry,
• line 10, to use ftok($0, 0) instead of my original '1234' id,
• line 17, to use op(0, 1, SEM_UNDO) in place of my setval(0, ($semval+1)), and
• line 31, to use op(0, -1, SEM_UNDO) in place of my setval(0, ($semval-1))
resulting in the code below (rev. of previous code)? Are there any other obvious problems (that might lead to race conditions, for example) in the code below?

I actually don't want the extraneous ones to block, but to go ahead and exit, because other instances can pick up and process waiting data later-I just don't want to slam the machine with a huge number of processes doing heavy processing at once.

#!/usr/bin/perl -w

use strict;

use IPC::SysV qw(IPC_PRIVATE S_IRWXU IPC_CREAT SEM_UNDO ftok);
use IPC::Semaphore;

srand;

my $sem =
  new IPC::Semaphore( ftok( $0, 0 ), 1, S_IRWXU | IPC_CREAT );

my $semval = $sem->getval(0);
$semval = 0 unless ( defined($semval) );

exit(0) if ( $semval >= 10 );
$sem->op( 0, 1, SEM_UNDO );

#
# Do work... or in this case, 
# print the value of $semval and sleep for a while
#
print $semval + 1, "\n";
sleep( int( rand(20) + 1 ) );

#
# Decrement the semaphore value
#
$semval = $sem->getval(0);
if ($semval) {
    $sem->op( 0, -1, SEM_UNDO );
}
else {
    $sem->remove;
}
__END__
#
# Sample test execution (in bash):
#
# index=500
# while [ $index -gt 0 ] 
# do 
#     perl test.pl & 
#     let "index=index-1" 
# done
#
[download]

You don't need to do a 'getval(0)' to check the value of the semaphore. If you set the flags to SEM_UNDO | IPC_NOWAIT, and check the return result and $!. If $! is EAGAIN then the semaphore value was 0 so no slots would be available and $sem->op() returned without altering the semaphore's value.

use Errno qw/EAGAIN EINTR/ ;

$result = $sem->op(0, -1, SEM_UNDO | IPC_NOWAIT)
if( !$result && $! == EAGAIN ) {
   # semaphore was zero, no slots available
   print "BUSY, try later\n" ;
   exit(0) ; 
}
die "op failed: $!" unless $result ; # op failed for some other reason

##
## lock acquired
##
[download]

Blocking isn't really as bad as it sounds. The process will just wait until one of other instances finishes and then increments the semaphore to something greater than 0. How long that takes depends on how many others are competing to decrement the semaphore at the same time.

If you want, you can add a time out using 'alarm'.

alarm(5) ; # five seconds
$success = semop
$result = int $! ; # capture the value of errno 
alarm(0) ; # cancel alarm(if still active)
if( !$sucess && $result == EINTR ) {
   # timed out
}
[download]

• line 17: op(0, -1, SEM_UNDO) in place of setval(0, ($semval+1))
• line 31: op(0,  1, SEM_UNDO) in place of setval(0, ($semval-1))
  
  Semaphores DECREMENT to lock, and INCREMENT to unlock.

A better solution might be to implement an extended "highlander"-style solution as presented in my column that flocks one of N files instead of just one file. Then, if the process aborts for any reason, the flock is dropped, and a new process can claim its rightful slotishness.

I've had that extension to the highlander solution on my column to-do list for a number of months; perhaps it is time to finally write it up.

I beg to differ on what happens when the process aborts. If you have the SEM_UNDO flag set on your operations, all of the collective operations on that semaphore are 'undone'. I refer to the semop man page, and will see what my other reference material says about it in the morning.