Why these finalizers only run on shutdown?

[audetto]

Why the following script only runs finalizers after the last line?

I have read all the disclaimers about the non deterministic nature of FinalizationRegistry and gc(), but from this little experience it looks super deterministic, just not the way I wished.

I tried to change number of iterations and array size to put more pressure, to no avail.

I run it as
node --expose-gc --trace-gc example.js
node --expose-gc example.js
node example.js

using v18.13.0 on Ubuntu 23.04.

Clearly this is toy example, but when I look at the behaviour of https://nodejs.org/api/n-api.html#napi_create_external for a c++ wrapper I wrote, I get the exact same behaviour, so I think it is something deeper.

const registry = new FinalizationRegistry((heldValue) => {
  console.log(heldValue);
});

function main() {
  for (let i = 0; i < 1000; ++i) {
    registry.register(new Array(10000), i);
    if (global.gc) {
      global.gc();
    }
  }
}

main();
console.log("============== END OF SCRIPT ==============");

[bnoordhuis]

Because you didn't tickle the garbage collector the right way.

[audetto]

Are you going to suggest a modification to make it work?

[bnoordhuis]

No, because you are asking a not-even-wrong question.

[audetto]

I have a new example, an explanation and more questions

Example

let created = 0;
let destroyed = 0;

const registry = new FinalizationRegistry((heldValue) => {
  ++destroyed;
});

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function main() {
  for (let i = 0; i < 1000; ++i) {
    registry.register(new Array(100000), i);
    ++created;
    console.log(`Destroyed: ${destroyed} Alive: ${created - destroyed}`);
    await sleep(0);  // give space to the finalisers
  }
}

main();

This time the finalisers are called: one can check if the number of Destroyed is > 0, e.g. Destroyed: 978 Alive: 22,
but if the sleep line is commented out, the output is: Destroyed: 0 Alive: 1000.

Explanation

Since node is single threaded, the main thread must yield for the finalisers to run.
A similar example in java would run finalisers in a separate thread, but in node this is not possible.

Not surprisingly, all the working examples one can find online involve setTimeout.
This explains as well why finalisers run after the end of the script in all cases: the main thread is paused.

Questions

1. Is this correct?
2. I imagine this is not an issue for a client-server application, which has a lot of "pauses" already. If this is not the case, is there anything better than await sleep(0) to let the scheduler run the finalisers?
3. Is it possible to schedule the finalisers in a separate thread? (if this makes any sense at all)
4. Is this documented anywhere?

[bnoordhuis]

1. to a first approximation (a script can't interrupt itself so yes, in that respect it needs to yield)
2. no
3. no
4. no, besides the guarantees made by the spec

[audetto]

4. documentation: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry

It is very clear that there are no guarantees about anything.
On the other hand, if someone spent time to design, spec and implement this, they must have thought it would be useful to something.

I still believe the doc (mozilla? V8? node? which one?) should include a decent example including something about this "yield" thing.

[bnoordhuis]

You could perhaps petition MDN but V8 or Node are unlikely to pin down what is basically a snapshot in time. The spec is open-ended precisely because implementers want leeway for future improvements.

[audetto]

mdn/content#26486

[audetto]

It is actually a very common issue, which I think deserves at least a good example with the current limitations.

#42651
mmomtchev/pymport#3
nodejs/node-addon-api#1140