As a matter of cosmic history, it has always been easier to destroy than to create." -
Spock
Spock is the kind of guy who preferred C++ with its destructors (let alone multiple inheritance), and that quote clinches it.
But it's also pretty easy to destroy in Dygraphs, you just have to remember to do it. And if you don't remember, you might have to pay a penalty.
Have you used the Dygraphs benchmark? It's a great tool for validating that your browser can handle large loads of dygraphs data. For instance, here's a URL that generates 50,000 points of data, which it tends to render in about half a second:
http://dygraphs.com/tests/dygraph-many-points-benchmark.html?points=100&series=500
Actually, today we aren't going to talk about Spock, or speed, we're going to talk about
memory leaks.
Thanks to an excellent
post on using the Chrome Inspector to diagnose and find memory leaks, we can see. Read that post to see how to track memory consumption. For this test, I used the URL above, and clicked "Go!" five times in a row (as opposed to setting repetitions=5)
Notice how over time, memory seems to go up, and never down. A sure sign of a memory leak.
The post also covers the notion of
heap snapshots and how to compare multiple snapshots. So as a follow-up I took a heap snapshot, clicked "Go!" once, took another snapshot, and compared them.
So, the number of graphs increased by two. That means the browser is holding on to two more instances of Dygraph, DygraphLayout, DygraphCanvasRenderer, you name it, with each new rendering. That could be the cause of our memory leak! (Remember that the benchmark shows two graphs, one which is benchmarked, and another one to show the values of each benchmark test.)
Let's see how the graphs are created in dygraph-many-points-benchmark:
plot = new Dygraph(plotDiv, data, opts);
new Dygraph(
document.getElementById('metrics'),
durations,
{ ... });
The first one, upon deeper inspection, might be assigned to a local variable, but the variable is never used. In other words, with every iteration, that graph is just forgotten about.
That's about when Dan told me about
Dygraph.destroy. According to the method's
documentation:
Detach DOM elements in the dygraph and null out all data references. Calling this when you're done with a dygraph can dramatically reduce memory usage. See, e.g., the tests/perf.html example.
So I address that first case with the following change:
if (plot) { plot.destroy(); }
plot = new Dygraph(plotDiv, data, opts);
So now, before re-rendering the benchmark graph, the old graph is destroyed.
That second example, the one which stores durations of each benchmark, isn't even stored somewhere to be destroyed at a later time. However, rather than dispose that graph each time, I did something slightly different:
var metrics = null;
if (!metrics) {
metrics = new Dygraph(
document.getElementById('metrics'),
durations,
{ ... });
} else {
metrics.updateOptions({file: durations});
Here, instead of destroying and recreating the graph, I just reuse it, pushing in new values using the
file option.
The result?
Steady memory usage. You can see a temporary bump which occurred at a period where I clicked Go! a little too quickly but even that memory was reclaimed. If you zoom in on the image, you can see small hiccups in the memory use every time I regenerated the graphs.
The takeaways:
- Don't assume your graphs are being destroyed when you no longer hold references to them.
- Hold references to your graphs so you can destroy them with Dygraph.destroy.
- Use updateOptions to replace graph data rather than constantly build new graphs.
- Go read the post on diagnosing memory leaks in Chrome. Go.
