You can use Devel::Peek to check reference counts of lexicals and PadWalker to hunt them down in closures.

HTH! :)

I'm afraid my original post wasn't entirely clear. Consider the following code:

package Foo;

my @objects;

sub new {
    my $self = bless {}, shift;
    push @objects, $self;
    return $self;
}

sub DESTROY { print "bye bye" }

package main;

{
    my $foo = Foo->new;
}

ETERNITY: while(1) {
    # DESTROY is NOT called yet.
}
[download]

When you run this, "bye bye" is not printed while we're waiting inside ETERNITY because @Foo::objects still holds a reference to $foo, even though its instantiation happened inside a scope we've since left.

What I want to be able to do is to discover whether and where similar @Foo::objects-like data structures exist in a large code base. So I need to walk the symbol tables and probe what's there. How do I find such symbols? Can I?

Hi RutgerVos: I assume you posted the code shown above.

When you write and show us code that demonstrates some painful consequence and then ask "How can I avoid this pain?", the obvious, simple and complete answer is "Don't do that!"

I suppose what you really mean is that other people, users of your code, are indulging nasty, unclean practices that are the source of the pain, such as exemplified by tobyink here. In this case, the only true solution is code review: go around and whack everyone's hand with a ruler until they stop doing the nasty. If a ruler doesn't work, use a hatchet. Others have pointed out tools to aid the review process, but you must ultimately persuade others not to do Bad Things with your code. Other than Good Practice, I'm not aware of any procedure in Perl that will 'armor' a reference, object or otherwise, against being circularized or otherwise given an infinite lifetime.

Here is how you should have written that

our @objecgts; ## @Foo::objects
... 
push @objects, weaken $object;
[download]

If you're going to do things the fudgy way, do it the easy fudgy way

They are probably not being referenced from the synbol table, but rather they're being referenced from other lexical variables.

use 5.010;
use strict;
use warnings;

END { say "Finished script; start of global clean-up" };

{
    package noisy;
    use overload q[""] => sub { $_[0][0] };
    sub DESTROY { say "$_[0] is being cleaned up" }
}

# Simple
{
    my $a = bless ['$a'], "noisy";
    say "defined $a";
} # $a gets cleaned up

# Linear refs
{
    my $b = bless ['$b'], "noisy";
    my $c = bless ['$c', $b], "noisy"; # refers to $b
    my $d = bless ['$d', $c], "noisy"; # refers to $c
    say "defined $b, $c, and $d";
} # $b, $c, $d get cleaned up

# Circular refs
{
    my $e = bless ['$e'], "noisy";  # we'll make this refer to $g soon
+!
    my $f = bless ['$f', $e], "noisy";  # refers to $e
    my $g = bless ['$g', $f], "noisy";  # refers to $f
    push @$e, $g;   # create reference cycle
    say "defined $e, $f, and $g";
} # $e, $f, $g cannot be cleaned up
[download]

Hello RutgerVos, and welcome to the Monastery!

You may find the module Test::LeakTrace useful. See e.g. the 2012 thread Leaking 0-length ARRAYs!?.

Hope that helps,

I've got a copy/paste about memory leaks