Are there any tips on efficient memory usage?

A few things to check for.

• If your passing hashes around between subs, make sure your passing them by reference not by by value.

  sub foo{
      my ($hashref) = @_;
      for my $key (keys %{$hashref}) {
          do stuff;
      }
  }
  
  my %hash = (Gobs=>'many', of=>'loads', data=>'Huge');
  ...
  foo( \%hash);
  [download]

  Instead of

  sub foo{
      my (%hash) = @_; #! Wrong!
      for my $key (keys %hash) {
          do stuff
      }
  }
  ...
  foo( %hash ); #! Wrong!
  [download]

  The second method will effectiviely double the memory usage for the hash. Go a third level deep that way and you triple it.

• Same applies to arrays.
• When processing your hashes, use

  while( my ($key, $value)= each %hash) { do stuff; }

  rather than for my $key (keys %hash) { do stuff; }

  On a hash containing 500,000 4-char keys, the latter method will consume an extra 20MB to build the list, the former essentially causes no growth.

• You mentioned "set operations". If you don't need to keep a copy of the original hashes...

  When doing unions, add the elements from the smaller of the two, to the larger rather than combining them into a third hash.

  Similarly intersections. Delete the elements one set from the other set rather than building a third.

  exists $b{$k} or delete $a{$k} while ($k,$v) = each %a;
  [download]

  rather than

  exists $b{$k} and $c{$k}=$v while ($k,$v) = each %a
  [download]

  If you do have to build a third hash to contain the results of such an operation and you discard it after processing, declare the temporary hash at as close a local scope as possible to ensure timely release.

• If your creating and destroying lots of temporary data structures, it might be worth using undef to prompt their timely destruction. I haven't found any way of verifying this yet--maybe someone else knows if this is no longer (or was ever) a useful thing to do.
• If your code is using all global vars, or if as in one or two cases I have seen here, the variables are being my'd in one huge lump at the top of the program or module, you should move as many of the declarations as close to their use as possible. Wrapping linear code in bareblocks and declaring the my's for temporary vars inside can reduce the footprint.

..and remember there are a lot of things monks are supposed to be but lazy is not one of them