node.js-需求错误导致内存泄漏？

Question

I have the following program which grows its heap continuously. It's a very simple program which repeatedly loads an external file ( SyntaxError ) via require . The external module fails to load because of a syntax error in it.

I run the node garbage collector and dump heap size to see if memory is leaking. If I fix the syntax error in the external file ( SyntaxError.js ), then the leak goes away and memory usage remains constant after a million iterations.

Using node version: 0.10.29 with --expose-gc

Any insights into what might be happening and how I can avoid mem leak would be greatly appreciated.

Test code:

(function() {
  var MAX_ITER_COUNT, MEGABYTE, dumpMem, gc, iterCount, noop, peakMem, test2;

  iterCount = 0;

  MAX_ITER_COUNT = 1000 * 1000;

  peakMem = 0;

  MEGABYTE = 1024 * 1024;

  noop = function() {};

  dumpMem = function() {
    var currentMem;
    currentMem = Math.round(process.memoryUsage().heapUsed / MEGABYTE);
    if (currentMem > peakMem) {
      peakMem = currentMem;
    }
    return console.log("" + iterCount + " - memory is: " + currentMem + "/" + peakMem + " MB");
  };

  gc = function() {
    return global.gc();
  };

  process.on("uncaughtException", function(err) {
    return console.log("Unhandled exception! ", err, err.stack);
  });

  test2 = function() {
    var e;
    iterCount++;
    try {
      /*
      Load a module that has a syntax error to create mem leak, and ignore exception
      */

      require("./SyntaxError");
    } catch (_error) {
      e = _error;
    }
    gc();
    dumpMem();
    return setTimeout(test2, 0);
  };

  test2();

}).call(this);

And SyntaxError.js:

(function() {
  'use strict';
  /* y does not exist, and results in exception*/

  var x;

  x = y;

}).call(this);

Answer 1

Seems like this is a node bug. I could work around it by putting the try/catch around the body of SyntaxError.js inside SyntaxError.js. My test, simplified from the above:

mem-leak-bug.js:

for (i=0; i<1000000; i++) {
    try {
        require('./mem-leak--error.js');
    }
    catch (e) { }

    if (i % 1000 === 0) {
        global.gc();
        console.log(i, process.memoryUsage().heapUsed/1e6|0, process.memoryUsage().heapTotal/1e6|0);
    }
}

mem-leak--error.js:
NOTE: there must be an explicit return in the catch block, else this too leaks memory

// throw an undefined variable exception
try {
    return x;
}
catch(e) {
    return;
}

Without the try-catch, it leaks memory:

% node --expose-gc ar/mem-leak-bug.js
0 1 5
1000 2 14
2000 2 14
3000 3 14
4000 3 23
5000 3 23
6000 4 24

With the try-catch inside SytaxError, it doesn't:

% node --expose-gc ar/mem-leak-bug.js
0 1 5
1000 1 7
2000 1 7
3000 1 7
4000 1 7
5000 1 7
6000 1 7
7000 1 7
8000 1 7