Try replacing

    &manager();
[download]

with

    goto &manager;
[download]

Well, the first answer is a good one. Let me explain it a bit. You have this code inside manager():

sleep(2);
&manager();
[download]

Every time a subroutine calls another subroutine, the stack grows. Each subroutine in the chain hangs onto whatever memory it has. When your stack gets big enough, you'll run out of memory or blow the stack -- both are fatal.

As an aside, you should really include use strict; use warnings; in your code -- you would have got a warning about deep recursion inside manager() long before you ran out of memory.

If you want to avoid this, you have two options: refactor your code so that manager() is just a loop, or use goto.

If you say goto &manager;, you're effectively¹ making a jump, not a call -- your stack remains constant.

Also, you should read perlvar, specifically the bits on my - variables that you only need inside of manager should be declared with that scope using my

1. As shmem explains below, it's not really implemented as a jump; however, the effect is so similar that the difference is unimportant for this convsersation. Still -- thanks to shmem for the clarification.

Updates:

• 20080611 : altered language, see footnote 1

If you say goto &manager;, you're making a jump, not a call -- your stack remains constant.

Not quite accurate; it's not a jump: a new stack frame is set up, the current stack frame is replaced by the new one, then unwound, so you have two of the same size. The memory used might remain constant, though. </nitpick>

;-)

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Its still doing it, slowly but surely this script eats all the RAM available! 0.5, 0.9, 1.4, 25... Dead! Is there a better way of writing this? It seems simple enough, but eventually the script will end with the out of memory error.

Ahhh, I completely forgot about that. That I was simply creating multiple copies of manager (which I was). Thank you very very much, it should solve my memory issue. ;)

I'm even using undef when I'm done with variables

Don't bother using undef to free memory, just let your variables go out of scope and let Perl's garbage collector work for you.

For instance, you should declare my @list and my @new_list inside the manager block.

Followup: better yet, don't use the arrays. Just iterate over the directory handle.

use strict;
use warnings;

my $thr;

# ...

sub manager() {
    local $| = 1;
    
    while (print '.') {
        opendir(my $dir_handle, './acc'); 
        
        FILE:
        while (my $file = readdir($dir_handle) ) { 
            
            # or use /.dat/ if that's what you meant
            next FILE if $file !~ /[.]dat$/;
    
            open(my $reader, '<', "./acc/$file"); 
            my @items = <$reader>; 
            close($reader);
            
            $thr = threads->new(\&initiator, @items);
            unlink("./acc/$file");
        }
        
        close($dir_handle);        
        sleep(2);
    }
}
[download]

Although I agree with the advice, Perl's behavior is actually more complicated. Sometimes undef does free memory.

Hello, THANK YOU SO MUCH FOR THE QUICK REPLY AND YES I'M YELLING IT! But could I also just do...

sub manager(){
  while(1){
  #same as before...
  }
}
[download]

To reduce memory usage? With or without the need for undef?

Yes that'll do the same as BrowserUK's quick solution: replace the endless recursion with a loop.

Perl doesn't treat tail recursion as speacial, so it's still bad. As in the original code.

Yes. Lose the undefs, they are doing nothing.

Use the strictures:

use warnings;
use strict;
[download]

Scalar value @in_items[0] better written as $in_items[0]
[download]

chomp can chomp all elements of a list at once, so there is no need to explicitly chomp each one:

chomp (my @in_items = @_);
[download]

It is a good practice to check the return value of open, opendir and system.

Avoid using $a and $b since they have special meaning for sort.

1. What about when the thread exits? Each time it initiates, they usually end a few minutes later... 2. Should I be fine now with goto / while(1) instead?