In the earlier weblog put up, I talked about how Node.js used memory usage measurement to check against memory leaks. Typically that’s adequate to provide legitimate assessments. Typically we would like the take a look at to be more precises and deal with the status of specific objects. This can be quite tricky with what’s out there to work together with V8’s garbage collector. One frequent strategy used by Node.js core test suites relies on the native v8::PersistentBase::SetWeak() API to invoke a “finalizer” when the noticed object is garbage collected. 3. At course of exit, if the callback set in 1 sees that the finalizer has not been invoked for enough times, the thing is taken into account leaking. The onGC() helper was launched before the FinalizationRegistry API turned available to JavaScript. It primarily serves the identical objective as FinalizationRegistry and invokes the ongc() callback for the first argument as a finializer. It's implemented with Node.js’s destroy async hook which is in turn applied with the v8::PersistentBase::SetWeak() API mentioend before.
external page The FinalizationRegistry API (a part of the WeakRef proposal) has been shipped since V8 8.4. This roughly serves the same purpose as the onGC() helper described above, however the callbacks are invoked via a mechanism completely different from that of the weak callback’s. In comparison with weak callbacks, the invocation of finalization registry callbacks usually happens later and is much less predictable. This is by-design to give JS engines more leeway in the scheduling of the callback and keep away from hurting efficiency. Technically the JS engine does not even must invoke the callback (the same can be said about weak callbacks, but they are much less complicated anyway). Finalizers are difficult enterprise and it is best to avoid them. They are often invoked at unexpected times, or not at all… The proposed specification permits conforming implementations to skip calling finalization callbacks for any cause or no cause. In practice though, the callback would only be known as for 99 times by the point the exit occasion is emitted - not less than when i tested it domestically.
As I’ve analyzed in one other blog put up, the false positives of Jest’s –deteck-leaks (which is based on FinalizatioRegistry) showed that you can't use gc() to make sure finalization registry callbacks to be known as for each object ever registered when they are rubbish collected, even in case you go so far as operating gc() for 10 times asynchronously, as a result of that’s not what they are designed for in the primary place. Finally, this relies on the regression that you're testing towards. If the leak reproduces reliably with every repeated operation that you're testing, one non-leaking pattern might already give you 90% confidence that you’ve mounted it and it’s not regressing once more. Of course, you may desire a 100% confidence and affirm this with each pattern, but given that observing finalization with a rubbish collector can already offer you false positives by design, a much less exact test with less false positives is healthier than a extra precise test with extra false positives. (Image: [[https://medclinres.org/wp-content/uploads/2025/01/The-Memory-Wave-550x550.jpg|https://medclinres.org/wp-content/uploads/2025/01/The-Memory-Wave-550x550.jpg)]]
As I’ve talked about in the other weblog put up, a simple gc() is normally not enough to wash up as many objects and invoke as many callbacks as potential, as a result of it’s simply not designed for that. Running it a number of times or maintaining the thread operating for a bit (in Node.js, utilizing setImmediate() to keep the event loop alive) can generally give V8 sufficient nudges to run your finalizers for unreachable objects (which was what Jest’s –detect-leaks did), however typically those methods are still not sufficient. In that case, if you depend on the finalizers to let you know whether or not your object will be collected or not, and consider the absence of finalizer invocations to be an indication of leaks, then you will have false positives. There is another caveat with gc() - if the graph being checked entails newly compiled features/scripts, and you are assuming that V8 can acquire them when they don't seem to be reachable by customers (which does happen normally), then the usage of gc() can bite you in the again because a forced GC induced by gc() alone can stop them from being rubbish collected.
That’s intentional, because gc() is a V8 internal API that solely caters to V8’s own testing wants, which includes this habits. That mentioned, generally it’s still inevitable for the regression assessments to pressure the garbage assortment by some means. Is there a extra reliable alternative to gc()? Nicely, one hack used by a few of Node.js’s checks in addition to a later fix to Jest’s –detect-leaks is to take a heap snapshot to perform some some form of final-resort garbage assortment. By design, a heap snapshot in intended to seize what’s alive on the heap as accurately as doable, so taking it urges V8 to begin the rubbish collection with some further operations to run as many finalizers as it may. The heap snapshot technology process additionally clears the compilation cache, Memory Wave which may help clearing scripts that wouldn't be in any other case collected if the GC is compelled by gc(). This helper takes an object manufacturing facility fn(), and run it as much as maxCount instances. Ideally the heap measurement limit ought to even be set to a smaller value to give V8 some sense of emergency to clean the constructed objects up because the allocation occurs. If the FinalizationRegistry callback for any objects returned from fn() will get called during the process, we know that at the least a few of these objects are collectable under Memory Wave Program strain, then we are assured sufficient about disproving the leak and stop there. To provide V8 extra nudges to invoke the finalizer, we’ll also take the heap snapshot at a specified frequency.
