AbortSignal.any() not destroyed when goes out of scope

[zdm]

Version

20.0.3

Platform

all

Subsystem

all

What steps will reproduce the bug?

AbortSignal.any( ...signals ) add events listeners to all passed signals and returns new AbortSignal instance.
This instance is not destroyed, when goes out of scope, because has listeners set.
And there is no possibility to unsubscribe from the child signals.

So, pltase, add method, which will allow to perform cleanup, for example clear().

How often does it reproduce? Is there a required condition?

Please, see above.

What is the expected behavior? Why is that the expected behavior?

Please, see above.

What do you see instead?

Please, see above.

Additional information

Please, see above.

[zdm]

Example:

#!/usr/bin/env node

import { setFlagsFromString } from "v8";
import { runInNewContext } from "vm";
setFlagsFromString( "--expose_gc" );
const gc = runInNewContext( "gc" );

const ac = new AbortController();

{
    let s = AbortSignal.any( [ac.signal] );

    s.addEventListener( "abort", console.log );

    s = null;
}

gc();

ac.abort();

Listener is called, even if signal is destroyed and V8 garbage collector is executed.

[zdm]

Another example:

#!/usr/bin/env node

import watch from "#core/devel/watch";
import gc from "#core/devel/garbage-collector";

{
    let s = {}

    watch( s ).on( "destroy", () => console.log( "--- DESTROY 1" ) );

    s = null;

    gc();
}

{
    let s = AbortSignal.any( [] );

    watch( s ).on( "destroy", () => console.log( "--- DESTROY 2" ) );

    s = null;

    gc();
}

Output:

--- DESTROY 1

watch - watch for object destroyed by garbage collector using FinalizationRegistry.

As you can see, signals, created with AbortSignak.any() are not destroyed at all.

[bnoordhuis]

Let me know if I misunderstand you but AbortSignal.any() is a web platform API, not a node-specific API, so if you want to change or extend it, you have to go through the proper channels. Closing.

[zdm]

As I see in the node sources - this method is nodejs specific.
Web api documentation dorsn't has any info about this.

Also, it now contain memory leak. I tried to run it un the loop anf see, that resident memory growth without lconstantly.

[zdm]

Please, reopen this issue, it requires fix.

[MoLow]

this behavior is expected and is more related to events than to AbortSignal.any

in your example

s.addEventListener( "abort", console.log );

creates an event listener, but nothing ever removes it, hence the memory leak.
you might want to do something like:

const handler =  (...args) => {
	s.removeEventListener("abort", handler);
	console.log(...args);
}
s.addEventListener( "abort", handler);

or simply

s.addEventListener( "abort", console.log, { once: true });

[zdm]

It contains mem leak. Also, just for info, it works very slow.

for ( let n = 0; n < 3; n++ ) {
    for ( let n = 0; n < 500_000; n++ ) {
        const a = AbortSignal.any( [] );
    }

    console.log( process.memoryUsage.rss() );
}

output:

1300037632
2685407232
3345960960

For example, new AbortController() doesn't leak mem:

for ( let n = 0; n < 3; n++ ) {
    for ( let n = 0; n < 500_000; n++ ) {
        const a = new AbortController();
    }

    console.log( process.memoryUsage.rss() );
}

output:

37724160
38465536
38465536

[MoLow]

I am reopening.
I agree AbortSignal.any( [] ) should not leak memory.

[MoLow]

CC @atlowChemi

[Linkgoron]

The behavior is because of how Weakrefs work, internally AbortSignal.any uses weakrefs and they will not get GCed until after a turn of the event loop.

e.g.:

for ( let n = 0; n < 3; n++ ) {
    for ( let n = 0; n < 500_000; n++ ) {
        const a = AbortSignal.any( [] );
    }

    console.log( process.memoryUsage.rss() );
}
setTimeout(() => {
    gc();
    setTimeout(() => {
        gc();
        console.log( process.memoryUsage.rss() );
    });
});

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef#notes_on_weakrefs

If your code has just created a WeakRef for a target object, or has gotten a target object
from a WeakRef's deref method, that target object will not be reclaimed until the end of 
the current JavaScript [job](https://tc39.es/ecma262/#job) (including any promise reaction 
jobs that run at the end of a script job). That is, you can only "see" an object get reclaimed
between turns of the event loop.

The any function always allocates a weakref (even when receiving an empty array). For the empty array case, I think that a guard can/should be added so that it won't allocate the relatively heavy object, but it won't solve the general "issue".

As I see in the node sources - this method is nodejs specific. Web api documentation dorsn't has any info about this.

https://dom.spec.whatwg.org/#dom-abortsignal-any

[zdm]

Pkease, add method, whist will allow correctly destory it, unlink from all watched signals and remove all listeners.
We don;t need to watch for abort, when this signal will foes out of scope, so we need to destory it.

Alos, it will be handy to add / reomve signals after it was constructed.

[Linkgoron]

As already stated, AbortSignal is a web platform API (yes it is implemented by Node itself, but it complies to a standard).

https://dom.spec.whatwg.org/#interface-AbortSignal