[Perf][SwiftSyntax] Stop interleaving unexpected node slots unless needed by rintaro · Pull Request #3458 · swiftlang/swift-syntax

rintaro · 2026-10-03T16:06:14Z

Layout nodes always had 2n + 1 child slots: n slots for their real children and n + 1 interleaved slots for unexpected nodes. In practice, unexpected nodes are rare, so most of those slots are nil. This change avoids allocating the unexpected-node slots unless at least one of them is populated.

RawSyntaxData.Layout now takes one of three RawSyntaxData.Layout.Storage forms:

.flat - A node with non-nil children; every collection and UnexpectedNodesSyntax
.layout - A layout node without unexpected nodes, each slot can be nil
.layoutWithUnexpected - A layout node that has something unexpected in it.

RawSyntaxData.Layout becomes { childCount: 4 bytes; byteLength: 4; descendantCount: 4; kind: 2; flags: 1; storage: 1; }, making it 16/16 bytes.

The tail allocated child buffer depends on the storage kind:

.flat stores exactly the number of children, all as non-nil RawSyntax.
.layout stores a fixed n-slot layout of "real" children as RawSyntax?.
.layoutWithUnexpected stores the same n child slots followed by a separate region of n + 1 unexpected-node slots.

Result

Against main (624d85e), two pairs, instructions and wall clock:

	instructions, pair 1 / pair 2	wall clock, pair 1 / pair 2
parse: MinimalCollections	−0.80% / −0.78%	−2.3% / −2.4%
decl_heavy	−0.82% / −0.86%	−6.2% / −5.0%
nonascii_heavy	−0.68% / −0.71%	−2.7% / −2.6%
corrupt_heavy	+0.01% / −0.01%	+0.2% / −0.1%
text consumers: `syntaxTextBytes`	−9.77% / −9.77%	−9.1% / −7.3%
`SourceLocationConverter`	−7.61% / −7.61%	−9.6% / −11.2%
`description`	−1.32% / −1.33%	+0.8% / −2.2%
reads: typed accessors	+0.19% / +0.58%	−0.9% / +1.5%
`rawText` reads	+0.24% / +0.73%	−1.7% / +0.9%
empty `SyntaxVisitor` walk	+1.41% / +1.43%	−2.3% / −1.6%
`children(viewMode:)` walk	+0.74% / +0.78%	+1.2% / +5.4%

tree memory over the 749 files	`main`	PR	change
a tree's size against its source	14.17×	10.15×	−28.3%
bytes allocated	136.5 MB	97.9 MB	−28.3%
slab memory taken	146.9 MB	107.2 MB	−27.0%

code size (`__text`)	change
SwiftSyntax	−2,968 bytes (−0.1%)
SwiftParser	+164 bytes (+0.0%)

`@_spi(RawSyntax)` changes

RawSyntaxLayoutView.children is a RawLayoutChildren rather than a RawSyntaxBuffer. It's a RandomAccessCollection of the children as the tree describes them.
Added: RawSyntaxLayoutView's realChild(at:), unexpectedSlot(at:), flatSlots, elements and interleavedRegions; RawSyntaxElements; and SyntaxKind.interleavesUnexpectedChildren.

rintaro · 2026-10-06T02:52:54Z

@swift-ci Please test

rintaro · 2026-10-06T04:44:44Z

@swift-ci Please test macOS

hamishknight · 2026-10-10T16:37:31Z

+            // Every slot is written exactly once — the `unexpected` ones exist
+            // only when they are being written — so initializing them and then
+            // assigning over them would be a `memset` of the whole tail for
+            // nothing.


This feels like an unnecessary comment for something the code doesn't do?

hamishknight · 2026-10-10T16:43:22Z

+      if hasUnexpected {
+        layout.initializeElement(at: 1, to: unexpectedBeforeProvider?.raw)
+      layout.initializeElement(at: 2, to: unexpectedAfterProvider?.raw)
+      }


Nit: Would be nice to fix the formatting here

hamishknight · 2026-10-10T16:55:38Z

+      /// Children with no `unexpected` slots among them: every collection, and the
+      /// layout kinds that do not interleave.
+      case flat
+      /// A kind that interleaves `unexpected` slots, in a node where every one of
+      /// them is empty, so it keeps room only for its real children.
+      case interleaved
+      /// A kind that interleaves `unexpected` slots, in a node where at least one is
+      /// occupied, so it keeps its real children and then all of them.
+      case interleavedWithUnexpected


This doesn't match the PR description, is that intentional? Given the storage isn't interleaved in these cases I think the names in the PR make more sense?

Ah, previously I was embedding the storage kind into the header (RawSyntaxData), When I moved it to Layout.storage I renamed them, but I agree interleaved is confusing, so I renamed back to layout

hamishknight · 2026-10-10T16:56:42Z

+  ///
+  /// - Precondition: this is a layout node or a collection.
+  @inline(__always)
+  var slotBase: (base: UnsafePointer<RawSyntax?>, childCount: Int) {


Any reason not to return a buffer pointer?

Because childCount is not the actual count of the slot buffer, it does not include unexpected nodes in case of "with unexpected". But it's a bit confusing with Layout.Ref.slotBase, I'm just removing this accessor and make all the clients access slotBase and childCount separately.

hamishknight · 2026-10-10T17:00:40Z

+    switch layout.storage {
+    case .interleavedWithUnexpected:
+      unexpected = UnsafeBufferPointer(start: start + childCount, count: childCount &+ 1)
+      interleaves = true
+    case .interleaved:
+      unexpected = UnsafeBufferPointer(start: nil, count: 0)
+      interleaves = true
+    case .flat:
+      unexpected = UnsafeBufferPointer(start: nil, count: 0)
+      interleaves = false
+    }


Is this not layoutView.interleavedRegions?

Right, this is now built from interleavedRegions.

hamishknight · 2026-10-10T17:18:57Z

+    initializingWith initializer: (UnsafeMutableBufferPointer<RawSyntax?>) -> Void
  ) -> RawSyntax {
-    return .makeLayout(kind: kind, uninitializedCount: 0, arena: arena) { _ in }
+    // A layout node has at most 23 slots, so the temporary is small.


Just to make it clear it's not a structural property, just the current largest node

Suggested change

// A layout node has at most 23 slots, so the temporary is small.

// A layout node currently has at most 23 slots, so the temporary is small.

hamishknight · 2026-10-10T17:19:16Z

+      let interleaves = kind.interleavesUnexpectedChildren
+      // Real children are the odd slots when a kind interleaves, and all of them
+      // when it does not.
+      let childCount = interleaves ? (count - 1) / 2 : count


Should we assert that count is odd?

hamishknight · 2026-10-10T17:25:49Z

+  public var endIndex: Int { self.interleaves ? 2 &* self.real.count &+ 1 : self.real.count }
+
+  public subscript(position: Int) -> RawSyntax? {
+    precondition(position >= 0 && position < self.endIndex)


Using precondition here differs from realChild/unexpectedChild, should we be consistent?

Made it assert for consistency.
I originally was using precondition for realChild/unexpectedChild, but it slowed down. So I changed it to assert.

hamishknight · 2026-10-10T17:27:05Z

+  /// One shape per function: a reader of this inlines whichever of the two it needs,
+  /// and neither is large enough to cost the inlining of what it calls. Both in one
+  /// function is 766 instructions where the two are 271 and 300, and at that size the
+  /// compiler stops inlining `advancedBySibling` — which then runs once per slot of
+  /// every node.


Can you trim this comment? The instruction counts are likely to become outdated, and advancedBySibling is @inline(__always) so not sure that rationale holds?

hamishknight · 2026-10-10T17:27:20Z

+    if let elements = layoutView.flatSlots {
+      return createFlatLayoutData(parent, elements)
+    }
+    return createInterleavedLayoutData(parent, layoutView.interleavedRegions!, count: layoutView.logicalChildCount)


Any reason not to just pass the layoutView? I don't love passing tuples as arguments

Performance, .flatSlots, .interleaveRegions and .logicalChildCount all have switch raw.storage in it. They are merged into one switch_enum only when they are all inlined.

But I ended up with inlining both builders, as it turned out to be faster. Also the readability is fine.

A non-collection layout node interleaves an `unexpected` slot before its first child, between every pair and after the last, so n children take 2n + 1 slots. Over a 749 file corpus not one of 1,132,225 layout nodes had anything in any of them, and those slots were 56.8% of every layout child slot in the tree. A node keeps room for them only when one of them is occupied. The byte its fields had to spare says which: `.flat` for a node whose slots are all children, which is every collection and the layout kinds that opt out of interleaving, `.layout` for a node that kept only its real children, and `.layoutWithUnexpected` for a node that has something unexpected in it. The fields count real children rather than slots. The caller says which of the three it is building. The generated initializers know it statically — whether their kind has `unexpected` slots at all — and work out whether any of them is occupied, so every slot is written exactly once. The form that takes a layout as the tree describes it decides the shape from what it wrote, which is what every mutating operation goes through, so a rewritten node comes back as compact as its contents allow. Tests check that a node reached by mutating another cannot be told apart from the same node built outright, including after growing and shrinking repeatedly. A node's children are still what the tree describes, `unexpected` slots included, answering nil for a slot a node kept no room for. The readers that matter avoid working each position out: - The raw accessors ask for a real child or an `unexpected` slot by where it sits, with constant indices in the generated code, and check the index in debug builds only. So do the deprecated `add…` methods. - A collection's elements are read as its slots, and `firstToken` and `lastToken` visit only the children a node holds. - Collecting a tree's text, writing its description and scanning for line ends walk the slots a node kept rather than every position its kind names. - `SyntaxDataArena` writes a node's data buffer from the two regions a node keeps, so what lands in it, and every index a client uses to reach a child, is unchanged. - Building a node's data buffer reads a `.flat` node's slots as non-optional children without asking its kind. Over the corpus, a tree takes 97.9 MB where it took 136.5 MB, which is 10.15 times the source rather than 14.17. Fingerprints of all 749 trees are unchanged, walking every node with `viewMode: .all`.

rintaro · 2026-10-11T03:43:36Z

@swift-ci Please test

rintaro · 2026-10-11T04:20:50Z

@swift-ci Please test Windows

rintaro commented Oct 3, 2026

View reviewed changes

Comment thread Sources/SwiftSyntax/Raw/RawSyntax.swift

rintaro force-pushed the perf-parser-35-compact-layout branch 2 times, most recently from 4b19f37 to 0643d84 Compare October 4, 2026 14:26

rintaro changed the title ~~[Perf][SwiftSyntax] Tail allocate RawSyntax layout buffer, without interleaving unexpected node slots unless needed~~ [Perf][SwiftSyntax] Stop interleaving unexpected node slots unless needed Oct 5, 2026

rintaro force-pushed the perf-parser-35-compact-layout branch 4 times, most recently from 4df4dbb to 105276a Compare October 6, 2026 00:46

rintaro marked this pull request as ready for review October 6, 2026 00:51

rintaro requested review from hamishknight, hborla and nkcsgexi as code owners October 6, 2026 00:51

hamishknight approved these changes Oct 10, 2026

View reviewed changes

rintaro force-pushed the perf-parser-35-compact-layout branch from 105276a to 5aad887 Compare October 11, 2026 03:07

rintaro force-pushed the perf-parser-35-compact-layout branch from 5aad887 to 4d26df9 Compare October 11, 2026 03:31

rintaro merged commit 8453c53 into swiftlang:main Oct 11, 2026
42 checks passed

	// A layout node has at most 23 slots, so the temporary is small.
	// A layout node currently has at most 23 slots, so the temporary is small.

Conversation

rintaro commented Oct 3, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Result

@_spi(RawSyntax) changes

Uh oh!

Uh oh!

rintaro commented Oct 6, 2026

Uh oh!

rintaro commented Oct 6, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rintaro Oct 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rintaro commented Oct 11, 2026

Uh oh!

rintaro commented Oct 11, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

rintaro commented Oct 3, 2026 •

edited

Loading

`@_spi(RawSyntax)` changes

rintaro Oct 10, 2026 •

edited

Loading