I have a fairly complex Javascript app, which has a main loop that is called 60 times per second. There seems to be a lot of garbage collection going on (based on the 'sawtooth' output from the Memory timeline in the Chrome dev tools) – and this often impacts the performance of the application.
So, I'm trying to research best practices for reducing the amount of work that the garbage collector has to do. (Most of the information I've been able to find on the web regards avoiding memory leaks, which is a slightly different question – my memory is getting freed up, it's just that there's too much garbage collection going on.) I'm assuming that this mostly comes down to reusing objects as much as possible, but of course the devil is in the details.
The app is structured in 'classes' along the lines of John Resig's Simple JavaScript Inheritance.
I think one issue is that some functions can be called thousands of times per second (as they are used hundreds of times during each iteration of the main loop), and perhaps the local working variables in these functions (strings, arrays, etc.) might be the issue.
I'm aware of object pooling for larger/heavier objects (and we use this to a degree), but I'm looking for techniques that can be applied across the board, especially relating to functions that are called very many times in tight loops.
What techniques can I use to reduce the amount of work that the garbage collector must do?
And, perhaps also – what techniques can be employed to identify which objects are being garbage collected the most? (It's a farly large codebase, so comparing snapshots of the heap has not been very fruitful)
Best Answer
A lot of the things you need to do to minimize GC churn go against what is considered idiomatic JS in most other scenarios, so please keep in mind the context when judging the advice I give.
Allocation happens in modern interpreters in several places:
new
or via literal syntax[...]
, or{}
.(function (...) { ... })
.Object(myNumber)
orNumber.prototype.toString.call(42)
Array.prototype.slice
.arguments
to reflect over the parameter list.Avoid doing those, and pool and reuse objects where possible.
Specifically, look out for opportunities to:
split
or regular expression matches since each requires multiple object allocations. This frequently happens with keys into lookup tables and dynamic DOM node IDs. For example,lookupTable['foo-' + x]
anddocument.getElementById('foo-' + x)
both involve an allocation since there is a string concatenation. Often you can attach keys to long-lived objects instead of re-concatenating. Depending on the browsers you need to support, you might be able to useMap
to use objects as keys directly.try { op(x) } catch (e) { ... }
, doif (!opCouldFailOn(x)) { op(x); } else { ... }
.JSON.stringify
which uses an internal native buffer to accumulate content instead of allocating multiple objects.arguments
since functions that use that have to create an array-like object when called.I suggested using
JSON.stringify
to create outgoing network messages. Parsing input messages usingJSON.parse
obviously involves allocation, and lots of it for large messages. If you can represent your incoming messages as arrays of primitives, then you can save a lot of allocations. The only other builtin around which you can build a parser that does not allocate isString.prototype.charCodeAt
. A parser for a complex format that only uses that is going to be hellish to read though.