in reply to Avoid Locking Entire Hashes

The lock doesn't have to the be on the variable you are changing, so create a hash of mutexes. 

my %h : shared;
my %mutexes : shared;

sub get_mutex {
   my ($k) = @_;

   my $mutex_ref = $mutexes{$k};
   return $mutex_ref if $mutex_ref;

   lock($mutexes);
   my $new_mutex : shared;
   return $mutexes{$k} ||= \$new_mutex;
}

sub safe_set {
   my ($k, $v) = @_;
   lock ${ get_mutex($k) };
   $h{$k} = $v;
}

[download]

Update: Fixed error mentioned in reply.

Replies are listed 'Best First'.
Re^2: Avoid Locking Entire Hashes
by jagan_1234 (Sexton) on Jun 13, 2011 at 21:25 UTC
    Thank you so much! That is a pretty nice solution, except of course it consumes a mutex variable per row. This drawback can be easily reduced to a smalller pool of mutexes rather than one per row. Thank again. BTW, I think the following line in your code is not thread safe; 
         my $mutex = $mutexes{$k} ||= do { my $mutex : shared; \$mutex };

    [download]
    We may need something like this: 
    my $mutex = $mutexes{$k};
if (! defined $mutex) {
   lock($mutexes);
    if (!defined $mutexes{$k}) {
          my $new_mutex : shared; 
          $mutexes{$k} = \$new_mutex 
          $mutex = \$new_mutex
    }
}

    [download]
    This means that you have to lock the entire mutexes the first time you see it..
[reply]
[d/l]
[select]
      That is a pretty nice solution, except of course it consumes ...

      ... an entire mirror data structure, completely unnecessarily.

      Why not store the values in your existing hash using references to shared scalars, and lock the individual scalars directly rather than via a proxy? 

      sub safe_set {
   my $k = shift;
   my $v :shared = shift;

   lock $$h{ $k };
   $h{$k} = \$v;
}

      [download]

      The reasons why you can't lock individual hash elements are quite involved, but they boil down to the facts that:

      • the values in a hash are not indexed directly by the keys themselves. And the keys aren't stored internally in scalars.
      • the values in shared hashes aren't themselves shared scalars by default.

      A full explanation would probably require the original author to explain, but it probably comes down to the path of least resistance.

      Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
      "Science is about questioning the status quo. Questioning authority".
      In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
[d/l]

        Thanks! Fascinating solution except that I think it is not thread-safe.. 

        
TIMESTEP 0:

    Say, $h{$k} points to v1 
    Thread T0: Holding lock on v1
    Thread T1: Waiting on Lock on v1 

TIMESTEP 1:

    T0 changes $h{$k} = \$v2, releases lock on $v1

TIMESTAMP 2: (Thread T2 makes an entrance)

    Thread T2: Acquires Lock on v2, proceeds
    Thread T1: Acquires Lock on v1, proceeds
    <Race-around condition>

        [download]
[reply]
[d/l]

        This is my safe set exerciser, which does crashes giving out the following error.

        Thread <X> terminated abnormally: panic: MUTEX_LOCK (22) shared.xs:199 at ./thread_test.pl line 25.

        I checked this multiple times but did not find anything wrong with it. May be a problem with the safe_set as I indicated in my post or may be not? 

        #! perl -slw

use strict;
use threads;
use threads::shared;

our %h : shared;

# Setting up just a single row to increase chances 
# a race condition
our $k = 'AAA';
our $val : shared = 0;
our $THREADS = 50;
our $iter = 50;
$h{$k} = \$val;

# Safe_set similar to BrowserUk 
sub safe_set {
  my $v :shared;
  # Critical Section
  {
     lock ${$h{$k}};
     $v = ${$h{$k}} + 1;
     $h{$k} = \$v;
  }
}

# Keep locking to increment $$h{$k}
sub test_safe_set {
  for (my $i = 0; $i < $iter; ++$i) {
     safe_set();
  }
}

my @pool = map{
      threads->create(\&test_safe_set)
    } 1 .. $THREADS;

$_->join for @pool;

warn ${$h{$k}}, "failed\n" if ${$h{$k}} != $THREADS * $iter;

        [download]
[reply]
[d/l]

      except of course it consumes a mutex variable per row.

      As requested.

      BTW, I think the following line in your code is not thread safe;

      oh, true! The fix is good, but the "defined" are superfluous.

[reply]

In Section Seekers of Perl Wisdom