Does JavaScript setInterval() method cause memory leak?

Question

Currently developing a JavaScript based animation project.

I have noticed that, proper use of setInterval(), setTimeout() and even requestAnimationFrame allocates memory without my request, and causes frequent garbage collection calls. More GC calls = flickers :-(

For instance; when I execute the following simple code by calling init() in Google Chrome, memory allocation + garbage collection is fine for the first 20-30 seconds...

function init()
{
    var ref = window.setInterval(function() { draw(); }, 50);
}

function draw()
{
    return true
}

Somehow, within a minute or so, starts a strange increase in allocated memory! Since init() is called only for once, what is the reason for the increase in allocated memory size?

(Edit: chrome screenshot uploaded)

NOTE #1: Yes, I have tried calling clearInterval() before the next setInterval(). Problem remains the same!

NOTE #2: In order to isolate the problem, I'm keeping the above code simple and stupid.

Solution 1

EDIT: Yury's answer is better.

---

tl;dr IMO there is no memory leak. The positive slope is simply the effect of setInterval and setTimeout. The garbage is collected, as seen by sawtooth patterns, meaning by definition there is no memory leak. (I think).

I'm not sure there is a way to work around this so-called "memory leak." In this case, "memory leak" is referring to each call to the setInterval function increasing the memory usage, as seen by the positive slopes in the memory profiler.

The reality is that there is no actual memory leak: the garbage collector is still able to collect the memory. Memory leak by definition "occurs when a computer program acquires memory but fails to release it back to the operating system."

As shown by the memory profiles below, memory leak is not occurring. The memory usage is increasing with each function call. The OP expects that because this is the same function being called over and over, there should be no memory increase. However, this is not the case. Memory is consumed with each function call. Eventually, the garbage is collected, creating the sawtooth pattern.

I've explored several ways of rearranging the intervals, and they all lead to the same sawtooth pattern (although some attempts lead to garbage collection never happening as references were retained).

function doIt() {
    console.log("hai")
}

function a() {
    doIt();
    setTimeout(b, 50);
}
function b() {
    doIt();
    setTimeout(a, 50);
}

a();

http://fiddle.jshell.net/QNRSK/14/

function b() {
    var a = setInterval(function() {
        console.log("Hello");
        clearInterval(a);
        b();                
    }, 50);
}
b();

http://fiddle.jshell.net/QNRSK/17/

function init()
{
    var ref = window.setInterval(function() { draw(); }, 50);
}
function draw()
{
    console.log('Hello');
}
init();

http://fiddle.jshell.net/QNRSK/20/

function init()
{
    window.ref = window.setInterval(function() { draw(); }, 50);
}
function draw()
{
    console.log('Hello');
    clearInterval(window.ref);
    init();
}
init();​

http://fiddle.jshell.net/QNRSK/21/

Apparently setTimeout and setInterval are not officially parts of Javascript (hence they are not a part of v8). The implementation is left up to the implementer. I suggest you take a look at the implementation of setInterval and such in node.js

Solution 2

The problem here is not in the code itself, it doesn't leak. It is because of the way Timeline panel is implemented. When Timeline records events we collect JavaScript stack traces on each invocation of setInterval callback. The stack trace is first allocated in JS heap and then copied into native data structures, after the stack trace is copied into the native event it becomes garbage in the JS heap. This is reflected on the graph. Disabling the following call http://trac.webkit.org/browser/trunk/Source/WebCore/inspector/TimelineRecordFactory.cpp#L55 makes the memory graph flat.

There is a bug related to this issue: https://code.google.com/p/chromium/issues/detail?id=120186

Solution 3

Each time you make a function call, it creates a stack frame. Unlike lots of other languages, Javascript stores the stack frame on the heap, just like everything else. This means that every time you call a function, which you're doing every 50ms, a new stack frame is being added to the heap. This adds up and is eventually garbage collected.

It's kinda unavoidable, given how Javascript works. The only thing that can really be done to mitigate it is make the stack frames as small as possible, which I'm sure all the implementations do.

Solution 4

I wanted to respond to your comment about setInterval and flickering:

I have noticed that, proper use of setInterval(), setTimeout() and even requestAnimationFrame allocates memory without my request, and causes frequent garbage collection calls. More GC calls = flickers :-(

You might want to try replacing the setInterval call with a less evil self-invoking function based on setTimeout. Paul Irish mentions this in the talk called 10 things I learned from the jQuery source (video here, notes here see #2). What you do is replace your call to setInterval with a function that invokes itself indirectly through setTimeout after it completes the work it's supposed to do. To quote the talk:

Many have argued that setInterval is an evil function. It keeps calling a function at specified intervals regardless of whether the function is finished or not.

Using your example code above, you could update your init function from:

function init() 
{
    var ref = window.setInterval(function() { draw(); }, 50);
}

to:

function init()
{
     //init stuff

     //awesome code
     
     //start rendering
     drawLoop();
}

function drawLoop()
{
   //do work
   draw();

   //queue more work
   setTimeout(drawLoop, 50);
}

This should help a bit because:

1. draw() won't be called again by your rendering loop until it's completed
2. as many of the above answers point out, all of the uninterrupted function calls from setInterval do put overhead on the browser.
3. debugging is a bit easier as you're not interrupted by the continued firing of setInterval

Hope this helps!

Solution 5

Chrome is hardly seeing any memory pressure from your program (1.23 MB is very low memory usage by today's standards), so it probably does not think it needs to GC aggressively. If you modify your program to use more memory, you will see the garbage collector kick in. e.g. try this:

<!html>
<html>
<head>
<title>Where goes memory?</title>
</head>
<body>

Greetings!

<script>
function init()
{
    var ref = window.setInterval(function() { draw(); }, 50);
}

function draw()
{
    var ar = new Array();
    for (var i = 0; i < 1e6; ++i) {
        ar.push(Math.rand());
    }
    return true
}

init();
</script>

</body>
</html>

When I run this, I get a saw tooth memory usage pattern, peaking bellow around 13.5MB (again, pretty small by today's standards).

PS: Specifics of my browsers:

Google Chrome   23.0.1271.101 (Official Build 172594)
OS  Mac OS X
WebKit  537.11 (@136278)
JavaScript  V8 3.13.7.5
Flash   11.5.31.5
User Agent  Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.101 Safari/537.11

View more solutions

Comments

[Luqmaan]

@Barmar hmmm, how long did you wait?

[Barmar]

I just watched it for about a minute. There was one GC cycle that caused the memory to drop, then it started growing again. I stopped it when the memory was about twice the peak it had reached before the previous GC.

[matahari]

Yes, as I've posted in my original message, I am already aware of the garbage collection. It works. The thing that I can not understand is, why a single timer method, such as setInterval(), keeps eating memory? From your JSFiddle, I can see that from 1.1min to 4.8 min, memory allocation goes up (keeps increasing)! More memory it requests = more GC calls fired! In order to stop unnecessary GC calls, setInterval() needs to be "tamed" so that it will stop allocating memory...

[goat]

his question is "why does my simple program keep allocating memory, causing garbage collection"

[matahari]

Yes, garbage collection is OK. Maybe I should rephrase my question: Why a simple timer method is allocating so much memory? If we can figure that out, we can find a way of writing garbage collection friendly codes, with minimal GC calls. Necessary for flicker free animation...

[Luqmaan]

@user1928710 my bad. I'm looking into the correct question now. My guess is that the function calls keep getting pushed onto the stack.

[matahari]

Thank you inspectahdeck. Now we're getting somewhere :) I am afraid, I have a similar guess. Something related with function calls over-using stack.

[bfavaretto]

I doubt it's the stack, as you're not dealing with recursion here, but async operations.

[allyourcode]

Calling functions requires memory. I didn't mention that, because I thought that was obvious. matahari, don't concern yourself with this. "Premature optimization is the root of all evil": en.wikiquote.org/wiki/…

[matahari]

@inspectahdeck, by definition you're right. As allocated memory is sooner or later garbage collected, there is no memory leak. On the other hand, with various examples you've confirmed that there is a continuous memory allocation going on without our request. IMHO, getting garbage collected doesn't justify the problem.

[matahari]

@inspectahdeck, As I've posted on my original message, similar memory allocation problem occurs in requestAnimationFrame as well. (That is acceptable due to recursive function call. That's the nature of the beast.)

[matahari]

Since all timer/sync related calls (setInterval, setTimeout, requestAnimationFrame) lead to similar memory allocation problem (in one way or another), garbage collector friendly written code sooner or later hiccups!

[matahari]

Allocating 2-3 MB of memory and garbage collecting forever is strange. Since there is no recursion in setInterval() case, I'm sure there's a reasonable explanation for that from implementers point of view. I'm afraid, that point of view doesn't solve the problem.

[Luqmaan]

@matahari Is recursion really necessary for memory to be used? Any leads on your end? Have you taken a look at the way setInterval and setTimeout are implemented? github.com/joyent/node/blob/master/lib/timers.js#L218-238

[goat]

This isn't premature optimzation, hes doing animation, and when you wastefully allocate memory during animation loops you not only potentially hurt the framerate, but the main issue is that you cause a stutter/flicker when the garbage collector kicks in(user code doesnt execute while the garbage collector runs - and so your animation stops briefly).

[bfavaretto]

@inspectahdeck I think you're right, it's just the regular memory allocation required by each function call at th given interval.

[matahari]

Hopefully, we can get an official answer from chromium forum (code.google.com/p/chromium/issues/detail?id=167647), and learn if it's just the (ir)regular memory allocation requests by timer methods...

[Joseph Adams]

This wouldn't work, would it? Don't you need to pass the function to setInterval and not the return value?

[BradLaney]

He's not executing draw, he's passing the reference.

[Steven Don]

It would only be a reference without the () following draw.

[ICR]

It's probably worth noting that Javascript is a little unusual in putting stack frames on the heap.

[ICR]

It also needs to allocate the arguments object.