fix: Node.path takes a lot of time on deep construct trees#2873
Merged
Conversation
Every construct has a `Node`, and `Node.path` is computed on every access by walking the full scope chain up to the root and joining the ids. For most constructs this chain never changes once the construct is created: `scope` and `id` are readonly and there is no reparenting API. Callers that read `path` repeatedly - notably the aspect invocation loop in aws-cdk-lib, which uses it as a per-node dedup key - therefore recompute the same string over and over. On a large tree (~5.5k stacks) this was measured at hundreds of millions of `path` reads in a single synth. Cache the computed value on first access. This is safe because the path is immutable once the scope chain is established, and it produces identical output while removing the repeated scope-chain walk.
ulrokx
marked this pull request as ready for review
July 15, 2026 18:47
cdklabs-automation
enabled auto-merge
July 15, 2026 19:04
rix0rrr
approved these changes
Jul 20, 2026
rix0rrr
changed the title
This was referenced Jul 21, 2026
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
4 participants
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.
Every construct has a
Node, andNode.pathandNode.scopesare computed on every access bywalking the full scope chain up to the root and joining the component ids.
These values never change once the construct is created, so we can just eagerly
calculate them instead. The lazy work was predicated on the assumption
that they might only rarely be read, but in practice CDK synthesis reads
both properties contstantly, and recalculating them incurs a heft cost
on deep construct trees.
The
most impactful case is the aspect invocation loop in
aws-cdk-lib(
invokeAspectsV2), which recurses the whole tree until it stabilizes anduses
node.pathas a per-node dedup-map key on every visit. On a large tree(~5,500 stacks) this was measured at hundreds of millions of
pathreads in asingle synth, dominating both CPU and GC.
This had a pretty nice performance benefit on a CDK package of ours, the synthesis times went from around 15 minutes to 8 minutes.
Testing
yarn test(full jest suite) passes.