test: remove impact of tier-up changes in worker stack size test - #64271
Merged
nodejs-github-bot merged 1 commit intoJul 7, 2026
Merged
test: remove impact of tier-up changes in worker stack size test#64271nodejs-github-bot merged 1 commit into
nodejs-github-bot merged 1 commit into
Conversation
Copy link
Copy Markdown
Member
Sorry, something went wrong.
The depth of the stack depends not only on the stack size, but also on the size of each stack frame, which in turn depends on which tier the recursive function happens to be running at when the overflow occurs. Under load the background tier-up can land at a non-deterministic point in the recursion and flake the test. Keep the recursive function in the interpreter with %NeverOptimizeFunction() so the frame size - and thus the depth - is deterministic. Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com>
targos
approved these changes
Jul 3, 2026
This comment was marked as outdated.
This comment was marked as outdated.
This comment was marked as outdated.
This comment was marked as outdated.
Copy link
Copy Markdown
Collaborator
Sorry, something went wrong.
jasnell
approved these changes
Jul 7, 2026
aduh95
pushed a commit
that referenced
this pull request
Jul 21, 2026
The depth of the stack depends not only on the stack size, but also on the size of each stack frame, which in turn depends on which tier the recursive function happens to be running at when the overflow occurs. Under load the background tier-up can land at a non-deterministic point in the recursion and flake the test. Keep the recursive function in the interpreter with %NeverOptimizeFunction() so the frame size - and thus the depth - is deterministic. Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com> PR-URL: #64271 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
RafaelGSS
pushed a commit
that referenced
this pull request
Jul 29, 2026
The depth of the stack depends not only on the stack size, but also on the size of each stack frame, which in turn depends on which tier the recursive function happens to be running at when the overflow occurs. Under load the background tier-up can land at a non-deterministic point in the recursion and flake the test. Keep the recursive function in the interpreter with %NeverOptimizeFunction() so the frame size - and thus the depth - is deterministic. Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com> PR-URL: #64271 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
aduh95
pushed a commit
that referenced
this pull request
Aug 6, 2026
The depth of the stack depends not only on the stack size, but also on the size of each stack frame, which in turn depends on which tier the recursive function happens to be running at when the overflow occurs. Under load the background tier-up can land at a non-deterministic point in the recursion and flake the test. Keep the recursive function in the interpreter with %NeverOptimizeFunction() so the frame size - and thus the depth - is deterministic. Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com> PR-URL: #64271 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
Merged
1 task
MarshallOfSound
added a commit
to electron/electron
that referenced
this pull request
Aug 21, 2026
…ite (#53062) Backports nodejs/node#64271. The test compares the recursion depth two Workers reach before overflowing, but depth also depends on frame size, which changes when the recursive function tiers up mid-recursion. On a busy CI runner that lands non-deterministically and the depths end up >10% apart. Pin the function to the interpreter so the depth is stable. The fix is only in Node 26.6.0+, so it is carried as a patch until the Node roll picks it up.
MarshallOfSound
added a commit
to electron/electron
that referenced
this pull request
Aug 21, 2026
…ite (#53075) Backports nodejs/node#64271. The test compares the recursion depth two Workers reach before overflowing, but depth also depends on frame size, which changes when the recursive function tiers up mid-recursion. On a busy CI runner that lands non-deterministically and the depths end up >10% apart. Pin the function to the interpreter so the depth is stable. The fix is only in Node 26.6.0+, so it is carried as a patch until the Node roll picks it up. Co-authored-by: trop[bot] <37223003+trop[bot]@users.noreply.github.com> Co-authored-by: Sam Attard <sattard@anthropic.com>
MarshallOfSound
added a commit
to electron/electron
that referenced
this pull request
Aug 21, 2026
…ite (#53076) Backports nodejs/node#64271. The test compares the recursion depth two Workers reach before overflowing, but depth also depends on frame size, which changes when the recursive function tiers up mid-recursion. On a busy CI runner that lands non-deterministically and the depths end up >10% apart. Pin the function to the interpreter so the depth is stable. The fix is only in Node 26.6.0+, so it is carried as a patch until the Node roll picks it up. Co-authored-by: trop[bot] <37223003+trop[bot]@users.noreply.github.com> Co-authored-by: Sam Attard <sattard@anthropic.com>
MarshallOfSound
added a commit
to electron/electron
that referenced
this pull request
Aug 21, 2026
…ite (#53077) Backports nodejs/node#64271. The test compares the recursion depth two Workers reach before overflowing, but depth also depends on frame size, which changes when the recursive function tiers up mid-recursion. On a busy CI runner that lands non-deterministically and the depths end up >10% apart. Pin the function to the interpreter so the depth is stable. The fix is only in Node 26.6.0+, so it is carried as a patch until the Node roll picks it up. Co-authored-by: trop[bot] <37223003+trop[bot]@users.noreply.github.com> Co-authored-by: Sam Attard <sattard@anthropic.com>
MarshallOfSound
added a commit
to electron/electron
that referenced
this pull request
Aug 21, 2026
…ite (#53078) Backports nodejs/node#64271. The test compares the recursion depth two Workers reach before overflowing, but depth also depends on frame size, which changes when the recursive function tiers up mid-recursion. On a busy CI runner that lands non-deterministically and the depths end up >10% apart. Pin the function to the interpreter so the depth is stable. The fix is only in Node 26.6.0+, so it is carried as a patch until the Node roll picks it up. Co-authored-by: trop[bot] <37223003+trop[bot]@users.noreply.github.com> Co-authored-by: Sam Attard <sattard@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Background: this is flaking in the canary as https://chromium-review.googlesource.com/c/v8/v8/+/7761796 made the function eligible for maglev tier-up. Locally this made the flake disappear for me. Opening against the main branch since it makes sense here anyway.
The depth of the stack depends not only on the stack size, but also on the size of each stack frame, which in turn depends on which tier the recursive function happens to be running at when the overflow occurs. Under load the background tier-up can land at a non-deterministic point in the recursion and flake the test. Keep the recursive function in the interpreter with %NeverOptimizeFunction() so the frame size - and thus the depth - is deterministic.