Javascript memory leak setTimeout issue

Question

Does any one know why memory consumption stays constant here ?

var count = 0;
$(init);
function init(){
 var node = document.querySelector('.logs');
 function check(){
 var uArr = new Uint16Array(100);
 log(node, uArr.length);
 setTimeout(check,100);
 } 
 setTimeout(check,100);
} 
function log(node, text){
 if( count % 30 == 0 ){
 node.innerHTML = '';
 }
 var child = document.createElement('div');
 child.innerText = 'count ' + (count++) + " arr len " + text;
 node.appendChild(child);
}

---

http://jsfiddle.net/V99Eb/11/

Reason why it should linearly increase memory allocation is: the 'check' method calls itself inside it's definition, so the closure variables will be available to the inside check method execution, which then again creates an execution context for the test function and so on.

Also, in every execution, we create a memory block of Uint16Array, which I believe is allocated in the heap, and should never get de-allocated since it is reachable from the closure.

Memory Profile: enter image description here

Looking at the memory timeline, it does not seem to increase memory allocation as the time increases. Is this the expected behavior ?

• cookie monster: Why does your title claim a memory leak issue when in fact you're demonstrating that there is no memory leak?
• jfriend00: uArr is only a local variable whose lifetime is only the current execution of check(). As soon as one invocation of check() finishes, that invocation's local variables are eligible for garbage collected because there is no longer any code that can reach them. The only variable that survives indefinitely in the closure is node.

Answer 1

uArr is just a local variable that is allocated, used, and then garbage collected after check() exits. And there is no closure inside check(). setTimeout() is invoked (but not defined) by check().

This page on Closures may be helpful.

While it is true that if there are N calls to check(), there would have been N closures created (as well as N copies of node), setTimeout() will release its reference to check() after it calls it. Therefore, there is no leak there either.

• jfriend00: Your first sentence is not quite true. If you put a call to an async function with an anonymous completion callback function as an argument in a for loop that does N iterations, you will get N separate closures. The layout determined that there would be a closure, but the N closures themselves were created as the code executed because of the path of execution.
• cybersam: @jfriend00 You are correct. Thanks! I've modified my answer.