Needs discussion / clarification: if cleanup doesn't iterate all weak cells, when will it be called again?

[marjakh]

Assume the WeakFactory's cleanup function does not retrieve all dirty WeakCells from the iterator. When will the cleanup function be scheduled to be called again?

0. Immediately (i.e., post another cleanup task immediately to the microtask queue, i.e., let other already scheduled microtasks run and call cleanup again)
1. Whenever GC finds another dirty WeakCell belonging to the same WeakFactory
2. Whenever GC finds another dirty WeakCell belonging to any WeakFactory
3. Something else?

[marjakh]

There's another option:
3. Whenever we do GC
4. Something else

[fitzgen]

Immediately (i.e., post another cleanup task immediately to the microtask queue, i.e., let other already scheduled microtasks run and call cleanup again)

This has a pathology if the cleanup function doesn't processs anything and no forward progress is made. We wouldn't want to keep enqueuing clean up jobs over and over that don't do anything :-p

[marjakh]

Yes. Listing it here for completeness :)

Btw, if the cleanup function doesn't iterate the WeakCells, but the program keeps creating new ones, memory will grow without limit. (Because we store the not-yet-iterated WeakCells.)

[fitzgen]

Another related idea: it may make sense for the reclaimed objects iterator to have a method to clear it out (which one would otherwise have to keep calling .next until it was finished). This would allow consumers to "gracefully" abandon cleanup.

[littledan]

I would suggest that the answer would be, "whenever the engine decides to, whether or not there are additional things collected". So this would permit 0, 1, 2 or 3. Any concerns with giving this sort of flexibility to engines?

[Jamesernator]

I think 1 would make the most sense as you can't be sure that the cleanup callback hasn't scheduled it's own work for when it wants to deal with the iterator. For example maybe the finalization callback is

const finalizer = holdings => requestIdleCallback(() => {
  for (const holding of holdings) {
    /* do some cleanup */
  }
})

or something like that.

[littledan]

I don't think we need much spec text for this issue, but we should come to a shared conclusion by Stage 3.

[littledan]

We promoted WeakRefs to Stage 3 based on the understanding that engines should schedule the finalizer to be re-called at a time that's good for them, based on whatever implementation-dependent data they have. Is there anything further that we should document?

[devsnek]

Why is the behaviour that the group would be re-queued at some point? Doesn't this just cause infinite loops?

[littledan]

@devsnek The callback will keep getting called if the iterator is not iterated through, but it won't get requeued immediately, but rather (in HTML) in another task, with possible further implementation-defined delay. Could you say more what you mean by "infinite loop"?

[devsnek]

@littledan "keep getting called" is what I mean by an infinite loop.

const g = new FinalizationGroup(() => {
  Promise.resolve().then(() => {}); // more items on queue
});

g.register({});

// agent can never exit...