Perl Memory Management Guide — Reference Counting, Leaks, and Optimization

In this tutorial, you will learn about Perl Memory Management Guide. We cover key concepts, practical examples, and best practices to help you master this topic.

Perl memory management relies on reference counting for automatic cleanup, with Scalar::Util::weaken for breaking circular references, and Devel::Peek/Devel::Cycle/Devel::Size for profiling and leak detection in long-running applications.

Reference Counting

{
    my $scalar = "hello";
    my $ref = \$scalar;
    # $scalar has refcount 2 inside scope
    print "Still alive\n";
}
# Both $scalar and $ref are destroyed when scope exits

Weak References

use Scalar::Util qw(weaken);

my $data = { big => "data" };
my $strong = $data;      # strong ref, keeps data alive
my $weak = $data;
weaken($weak);           # weak ref, doesn't count

$data = undef;           # data still alive through $strong
$strong = undef;         # now data can be freed
print $weak;             # may be undef (data freed)

Circular References

# Circular reference -- memory leak
my $parent = { name => "Parent" };
my $child  = { name => "Child", parent => $parent };
$parent->{child} = $child;  # cycle!

# Fix with weak reference
use Scalar::Util qw(weaken);
$parent->{child} = $child;
weaken($child->{parent});   # break the cycle

Memory Profiling

use Devel::Size qw(size total_size);

my $data = {
    array => [1..1000],
    string => "x" x 1000
};

print "Shallow size: " . size($data) . "\n";
print "Total size: " . total_size($data) . "\n";

# Devel::Peek shows internal structure
use Devel::Peek;
Dump($data);

Common Mistakes

1. Circular references in objects

Parent-child relationships in OOP create cycles. Use weaken on the child's parent reference.

2. Closures capturing large data

Anonymous subs keep referenced variables alive. Clear references when closures are long-lived.

3. Global variables holding data

Package variables persist for the program's life. Use local or lexical scope for temporary data.

Practice Questions

1. How does Perl manage memory? Reference counting: each value has a count of references. When count reaches 0, memory is freed.

2. How do you create a weak reference? weaken($ref) from Scalar::Util turns a reference into a weak reference.

3. How do you find memory leaks in Perl? Use Devel::Cycle to detect circular references, Devel::Leak to track allocations.

FAQ

{{< faq question="Does Perl have a garbage collector?" >}} Perl uses reference counting, not a tracing GC. Circular references are handled specially -- Perl periodically scans for cycles. {{< /faq >}}

{{< faq question="How do I check reference count?" >}} Use use Devel::Peek; Dump($ref) and look for SvREFCNT in the output. {{< /faq >}}

{{< faq question="What happens when a weak reference target is freed?" >}} The weak reference becomes undef. Check with defined($weak) before using. {{< /faq >}}

What's Next

Now that you've completed the Perl tutorial series, explore other languages.