Cool. Hadn't realized that was the case about hash keys.

I'm a little surprised at the refaddr versus 0+$self conclusion, though -- I would have thought that refaddr is just XS that returns a memory address, whereas 0+$self would wind up casting things to Perl scalars with associated overhead. I guess it's optimized away. Good to know.

Even more efficient would be to write a custom hash loading routine in XS that a) extracts the refaddr automatically, and b) uses the binary representation of the address as the key for the hash lookup/storage. Currently when you use $hash{0+$self}=$foo you are doing itoa() on the address, then using the resulting string for the hash key. If the addresses binary representation was used as the key they keys would be fixed length, and would not require the itoa() step, and would be much faster. I imagine this would about 4-8 lines of XS code and would be drammatically faster than using $hash{0+$self}. Ie I can imagine an API like:

ref_key_store(%hash,$ref,$value);
my $val=ref_key_fetch(%hash,$ref);
[download]

---
$world=~s/war/peace/g

The performance of the blessed hash case is dependent on the length of the keys used in the hash: The longer the key, the more time it takes!

You're right, but this isn't the reason that using $self is so much slower. Stringification of references is just slow:

#! /usr/bin/perl

use strict;
use warnings;
use Benchmark qw( cmpthese );

my $self = bless {}, 'SomeClass';
my $string = "$self";

my %a = ( $self => 0 );
my %b = ( $string => 0 );

cmpthese(-1, {
    self    =>  sub { $a{ $self } = $a{ $self } + 1 },
    string  =>  sub { $b{ $string } = $b{ $string } + 1 },
});

__END__

# on my perl 5.8.7
           Rate   self string
self   156393/s     --   -83%
string 927942/s   493%     --
[download]

On another minor note, 0+$self yields the same result as the refaddr function.

Unless you overload arithmetic.

On another minor note, 0+$self yields the same result as the refaddr function. So you can eliminate 'use Scalar::Util', and just cache 0+$self.

Only when nummification is NOT overloaded. And in earlier perls you can't unoverload nummification.