threads::tbb::concurrent::hash - shared hash via tbb::concurrent_hash_map
use threads::tbb; #my @array :concurrent; # TODO tie my %hash, "threads::tbb::concurrent::array"; $hash{foo} = "bar"; # unsafe, use for initializing only print $hash{foo}; # safe, but hangs while write locked # threadsafe access with exclusive lock: my $lock = (tied %hash)->writer($key); print $lock->get(); # starts as undef $lock->set("new value"); undef($lock); # release lock # threadsafe access with share (read-only) lock: $lock = (tied %hash)->reader($key); # may return undef print $lock->get(); undef($lock); # release lock
The concurrent hash is a Perl tied hash that multiple threads can read to and write from. It also provides the advantage of using cache-aligned hash slots, so threads don't conflict on nearby access with each other.
Implementation of basic hash primitives is incomplete; stick with the concurrent API and you will be fine. Patches welcome!
These methods will get you a new instance of a threads::tbb::concurrent::hash;
threads::tbb::concurrent::hash
Both of these class methods return a new concurrent hash container.
The TIEHASH constructor is provided for the tie built-in (see "tie" in perlfunc and perltie).
tie
The thread-safe operations on this type are:
Tied API. Access a slot in the hash. This will only return immediately if there are no other locks held on this hash slot (see below). As there is no lock object returned, this access method always deep-clones the return value.
Returns a const accessor for the slot at key, or undef if there is no slot there. If the slot exists, and contains undef or any other scalar value, the function will return a lazy clone handle to it. You may get a copy of the scalar in $slot with its ->get() method:
key
undef
$slot
->get()
my $slot = (tied %hash)->reader($key); my $value = $slot->get();
The key will have a share lock taken out - no exclusive (write) locks can exist or be taken out until the $slot value passes out of scope or is undefined.
Make sure that you do not save objects which were referenced from ->get() for longer than the lifetime of the locks, without cloning via Storable::dclone first. If you do, they must be completely constant values.
Storable::dclone
Returns a mutable accessor for the slot at key. If the slot does not exist, then it creates the slot with value undef first. The function will return a lazy clone handle to it which can also change the value. You may get a copy of the scalar in $slot with its ->get() method as above, and also change its value using its ->set() method:
->set()
my $slot = (tied %hash)->reader($key); $slot->get($key); my $value = $slot->get(); $slot->set($value);
The key will have an exclusive lock taken out - no other locks can exist or be taken out until the $slot value passes out of scope or is undefined.
No other operations are currently implemented; sadly, currently including iteration. So the tied hash is still quite deficient.
Also not yet supported is returning of a divisible hash key range for potential use with a new parallel_for or parallel_reduce body type.
parallel_for
parallel_reduce
Can't delete a slot (or all slots) at the moment..
Not yet implemented, but you can use the reader method of the tied object.
reader
This particularly badly designed API is required for keys to work, however implementation will not be straightforward - of course because of its awful side-effect-by-design nature.
keys
Currently the TIEARRAY method doesn't respect tieing to an array with existing contents.
threads::tbb::concurrent, threads::tbb
To install threads::tbb, copy and paste the appropriate command in to your terminal.
cpanm
cpanm threads::tbb
CPAN shell
perl -MCPAN -e shell install threads::tbb
For more information on module installation, please visit the detailed CPAN module installation guide.