Beefy Boxes and Bandwidth Generously Provided by pair Networks
Think about Loose Coupling

Re: "goto" memory leak

by dave_the_m (Monsignor)
on Mar 30, 2016 at 08:52 UTC ( #1159092=note: print w/replies, xml ) Need Help??

in reply to "goto" memory leak

Strictly speaking, it's a not a leak: the memory is reclaimed on scope exit. This code doesn't grow in memory usage after the first iteration of the while loop:
while (1) { $i = 0; again: my $x; goto again if $i++ < 100_000_000; }
Part of the run-time action of 'my' is to make a note to free the lexical at scope exit. The goto causes additional notes to be pushed on the savestack without any scope being exited. When the scope is finally exited, all the notes are popped off the savestack and processed.


Replies are listed 'Best First'.
Re^2: "goto" memory leak
by jethro (Monsignor) on Mar 30, 2016 at 12:35 UTC

    That depends on how you define "memory leak".

    At least under Wikipedias definition ("In computer science, a memory leak is a type of resource leak that occurs when a computer program incorrectly manages memory allocations1 in such a way that memory which is no longer needed is not released.") this still is a leak. Because the main scope is never exited (while the program is running) there is at least one scope that never releases its memory.

    And then there are closures. See the following code that also exhibits the memory leak:

    #!/usr/bin/perl my $i; top: while (1) { again: my $x; $i = 0; goto again if $i++ < 100_000; } goto top;

    Necessarily the hook variable has to be in the main scope (I assume), but the interesting thing is that the code seems to be minimal for the closure case, i.e. $i creates the closure, but $x is needed to create the leak.

    UPDATE:Anon Monk found a silly mistake in my code, the inner goto is an endless loop. The conclusion is wrong, I tested closures with teh following code and memory stayed low.

    sub closure { my $s; return sub { $s=5; my $i; } } my $f = closure(); while (1) { $f->(); }

      there is at least one scope that never releases its memory.

      In your original program, yes. It never releases memory, but that memory is still needed. That doesn't meet the definition of a leak.

      Keep in mind that the run-time effect of

      my $i;
      is similar to
      Hook::Scope::POST(sub { $i = undef });

      It pushes an instruction on the stack to clear the scope on exit (which could happen, say, if an exception occurs).

        Ok, but again we could argue over the definition of the word "needed". "Needed" by the program writer or "needed" by an implementation that keeps scopes around that are not accessible to the program writer anymore? EDIT: Ok, POST is a way to actually access such scopes, maybe even other introspection code, but the question is whether there is a need to create and keep these scopes at all when the writer does not indicate he wants them around?

        I'm more than happy with renaming the problem to "goto creates spurious scopes". The question that I can't answer is whether "goto" does that for a good reason, like "goto is harmful, and has to do this to jump in and out of nearly arbitrary scopes", or that it really is a bug.

      That snippet exhibits an infinite loop, or two. The goto is always taken since $i++ < 100_000 will always be true...

      Objects may have side effects when they are DESTROYed, so this must happen at some well-defined moment (scope exit). Gotos cannot create scopes as there is no way to determine the flow of the program.

Log In?

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://1159092]
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others romping around the Monastery: (5)
As of 2020-07-06 21:01 GMT
Find Nodes?
    Voting Booth?

    No recent polls found