debugger watchpoint behavior

[hexcoder]

Dear fellow monks!

In my application I had my %hash; along with some imported modules.

When my hash was populated completely (and should be constant afterwards), I wanted to see where and when $hash{'myEntry'} changed unexpectedly. But using a watchpoint w $hash{'myEntry'} in the debugger led to a lot of unwanted breaks: each time the package/module scope changed the visibility of %hash changed also, of course.

Has anyone solved this problem of how to ignore breaks from visibility/scope changes?
Thanks!

[haj]

I only have a workaround: set a break (or continue to the point) where %hash is initialized. Then create a reference to that hash with $href = \%hash, and watch with w $href->{'myEntry'}.

The variables you define in the debugger don't go out of scope. But note that the behavior of your code will change if you want %hash to go out of scope and maybe be re-initialized later: As long as the reference lives, %hash will stick around.

[LanX]

I didn't like the idea of having an extra reference count, because this smells like Heisenbug.

So I thought weakening it might be a good idea, but then I realized that the reference might change and the global var will fail.

Tricky. I could think of some approaches to solve this, but I'm AFK right now.

And the OP didn't show us any code...

[choroba]

If you know what the unexpected value is, you can set the watch expression to check the value is not the unexpected one, so it will stay true even for a non-existent value.

w $hash{key} ne "unexpected"

Note that if the value is changed on the last line of a subroutine, the debugger won't show it, instead it will notice the change the next time you enter the scope.

Example:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   my %hash;
    sub set {
        %hash = (a => 12, b => 14);
    }
    sub get {
        my ($key) = @_;
        return $hash{$key}
    }
    sub change {
        $hash{b} = 'Boo';
    }
}

set();

say get('b');

change();

say get('b');

[Danny]

This suggests creating a temporary global reference to your variable and "watching" that.

[hexcoder]

Thanks, I tested the tip from stackoverflow using a watch with a hash reference in a global variable, and it seemed to work!
BTW: I think this useful technique should be known more!

[Anonymous Monk]

Another way to find out where the hash is being changed is to use Hash::Util 'lock_hash'; and then lock_hash( %hash ); once it has been set up. This turns any attempt to assign to the hash into a fatal exception.

[The_Dj]

What I've had to do in such cases is to set a breakpoint with the condition.

e.g. if I have

%hash=(1,2,3,4);
while (1) {
  print "Something...\n";
  ===cut===
}


you can put in b 3 $hash{1} ne 2
In a real scenario you may need to run to after %hash is populated to find out what the value is

[LanX]

What if you created a global %hash which is a copy of the scoped %hash?

The global one would only be visible outside the scope and produce no value changes when watched.