Just wondering if there is a module or something out there in PERL that can be used to get the number of bytes in a hash

my %hash     = qw(foo one bar two baz three);
my $hash_len = 0;
$hash_len += length for values %hash;
print "hash length is $hash_len\n";

__output__

hash length is 11
[download]

_________
broquaint

Good solution... however, what if it's a multi-dimensional hash? Perhaps a recursive function that'll traverse the tree and find the number of bytes in each branch and eventually return it to the top?

However, I believer perl requires quite a few bytes extra for storing each scalar, as well as even more bytes to keep track of hash mappings, so if the purpose of this proposed chunk of code is to help work out memory constraint on a system, the value it returns will be optimistically low at best.

"Falling in love with map, one block at a time." - simeon2000

Hi,

Try not to link like that please, it can cause users to think that they have logged out (because the domain name you use in the link could be different from the one the users cookie is for).

A better way is to use the id:// monktag like so:

[id://73550]
[download]

This has the added advantage of being a bit easier to type and automatically converts to the node title name(hash size), as well as being displayed with the correct doamin name for the user.

Cheers,

Yves / DeMerphq
---
Writing a good benchmark isnt as easy as it might look.

I'm using this code, to get some basic informations about the central structures in a software where basically a hash structure is the top/central element:($self points to the hash)

  print "Buckets used/allocated:\t",scalar(%{$self}),"\n";
  while(($key,$value) = each %$self) {
    $num_keys++;
    $num_mu += scalar(@$value);
  }
  print "\t\tNumber Words/meanings:\t$num_keys/$num_mu\n";
[download]

Bye
 PetaMem

my %H = (
a => { aaa => 111 ,
       bbb => 222 ,
     } ,
b => { ccc => 333 ,
       ddd => 444 ,
     } ,
c => [a,b,c,d, {x=>555,y=>666} , [w,w,w] ] ,
);

my ($keys,$vals) = HASH_size(%H) ;
print "Size of keys: $keys\nSize of values: $vals\n" ;

#############
# HASH_SIZE #
#############

sub HASH_size {
  my (%hash) = @_ ;
  
  my ($KEYS_size,$VALS_size) ;
  
  foreach my $Key ( keys %hash ) {
    if ( ref( $hash{$Key} ) =~ /HASH/i) {
      $KEYS_size += length($Key)  ;
      my ($k,$v) = &HASH_size( %{$hash{$Key}} ) ;
      $KEYS_size += $k ;
      $VALS_size += $v ;
    }
    elsif ( ref( $hash{$Key} ) =~ /ARRAY/i) {
      $KEYS_size += length($Key)  ;
      my ($k,$v) = &ARRAY_size( @{$hash{$Key}} ) ;
      $KEYS_size += $k ;
      $VALS_size += $v ;
    }
    else {
      $KEYS_size += length($Key)   ;
      $VALS_size += length($hash{$Key})  ;
    }
  }
  
  return($KEYS_size,$VALS_size) ;
}

##############
# ARRAY_SIZE #
##############

sub ARRAY_size {
  my ( @array ) = @_ ;
  
  my ($KEYS_size,$VALS_size) ;
  
  for(0..$#array) {
    if (ref(@array[$_]) =~ /ARRAY/i) {
      my ($k,$v) = &ARRAY_size( @{@array[$_]} ) ;
      $KEYS_size += $k ;
      $VALS_size += $v ;
    }
    elsif (ref(@array[$_]) =~ /HASH/i) {
      my ($k,$v) = &HASH_size( %{@array[$_]} ) ;
      $KEYS_size += $k ;
      $VALS_size += $v ;
    }
    else {$VALS_size += length(@array[$_]) ;}
  }

  return( $KEYS_size,$VALS_size ) ;
}
[download]