Here's my guess: You have a memory leak (perhaps from using global variables), or if you are opening files and not closing them, you will eventually reach the max limit on file descriptors.

Try calling your perl script from a shell script loop:

#!/bin/ksh

TIMER=10
while :
do
    perl script.pl
    sleep $TIMER
done
[download]

my $TIMER = 10;
while (1) {
    do "/path/to/your/script.pl";
    sleep $TIMER;
}
[download]

Thanks for the quick response PrakashK, but I forgot to mention that I had tried your second option. The results of that made me even more confused as to what was going on. If I call the script from the command line, it will work fine. But it gives me the "overflow" problems if I call it from a file like this:

#!/usr/bin/perl

my $TIMER = 10;
$TEST = 1;
while ($TEST == 1) {
    do "mrtgnav.pl";
    sleep $TIMER;
    $TEST = 1;
}
[download]

Note the $TEST variable. When I run what you see above, it has the problem. But the program works when I try and fool it like this:

#!/usr/bin/perl

my $TIMER = 10;
$TEST = 1;
while ($TEST == 1) {
    do "mrtgnav.pl";
    sleep $TIMER;
    $TEST = 0;
}
[download]

Help. My head is starting to hurt...

I expect the reason it give you no problems the second way is that you're only running it once, sleeping for 10 seconds, and exiting (you exit the loop on the first time through).

I think you and PrakashK are both under a slightly misapprehension as to what do does: it "does" the code in a file you specify, but it does it within the name space of the currently running script (and it does the same thing every time you do it). This is very useful for importing configuration variables, but not very useful for avoiding memory leaks.

I suspect, therefore, that if you try substituting system for do, it will solve that problem, giving you an acceptable work-around for running the script repeatedly.

It will not solve your overall problem, however: most likely that is caused by the use of global variables in a non-scalable manner, as indicated by synapse0 and PrakashK. This can be solved by making your variables lexically scoped, using my (this makes it sound slightly simpler than it is). I'd explain why this is, but Dominus explains it so much better in Coping with Scoping (TPJ) that I'll just recommend that you read that instead. :-)

If you're modifying globals in your subroutines (which it seems very likely you are), don't do that! :-) Instead, pass values to them explicitly, and give them useful return values. If you write subs this way, casual readers like us (and you, two months from now) will be able to figure out which variables they modify, and mysterious bugs will be less likely to happen.

I strongly suggest using use strict; at the top of every large script you write (and the small ones too, just to keep in practice). Again, I'd explain exactly why (it has to do with those lexically scoped variables), but tachyon wrote a node precisely to avoid that duplication of effort, so I'll just point you to it: Use strict warnings and diagnostics or die. (Though if you're new to Perl I should perhaps note that he doesn't mean that last part entirely literally...)

Sorry for the somewhat scattershot nature of this reply--sometimes that's all my brain will produce.




---

If God had meant us to fly, he would *never* have give us the railroads.
    --Michael Flanders