Keep optional symbol tables out of hot symbol records (#64799)

Author: jakebailey

tsc/internal/ast/symbol.go

@@ -4,6 +4,7 @@ import (
 	"strings"
 	"sync/atomic"
 
+	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/debug"
 )
 
@@ -23,31 +24,81 @@ type symbolData struct {
 	name             string
 	declarations     []*Node
 	valueDeclaration *Node
-	members          SymbolTable
-	exports          SymbolTable
 	parent           *Symbol
-	exportSymbol     *Symbol
+	extra            *symbolExtra
+}
+
+type symbolExtra struct {
+	members      SymbolTable
+	exports      SymbolTable
+	exportSymbol *Symbol
+}
+
+// SymbolExtraArena batches optional symbol metadata without adding an allocator
+// pointer to every symbol. References from symbolData keep its blocks alive.
+type SymbolExtraArena struct {
+	arena core.Arena[symbolExtra]
 }
 
 func (s *Symbol) Flags() SymbolFlags      { return s.flags }
 func (s *Symbol) CheckFlags() CheckFlags  { return s.checkFlags }
 func (s *Symbol) Name() string            { return s.data.name }
 func (s *Symbol) Declarations() []*Node   { return s.data.declarations }
 func (s *Symbol) ValueDeclaration() *Node { return s.data.valueDeclaration }
-func (s *Symbol) Members() SymbolTable    { return s.data.members }
-func (s *Symbol) Exports() SymbolTable    { return s.data.exports }
 func (s *Symbol) Parent() *Symbol         { return s.data.parent }
-func (s *Symbol) ExportSymbol() *Symbol   { return s.data.exportSymbol }
+
+func (s *Symbol) Members() SymbolTable {
+	if s.data.extra == nil {
+		return nil
+	}
+	return s.data.extra.members
+}
+
+func (s *Symbol) Exports() SymbolTable {
+	if s.data.extra == nil {
+		return nil
+	}
+	return s.data.extra.exports
+}
+
+func (s *Symbol) ExportSymbol() *Symbol {
+	if s.data.extra == nil {
+		return nil
+	}
+	return s.data.extra.exportSymbol
+}
 
 func (s *Symbol) SetFlags(value SymbolFlags)      { s.flags = value }
 func (s *Symbol) SetCheckFlags(value CheckFlags)  { s.checkFlags = value }
 func (s *Symbol) SetName(value string)            { s.data.name = value }
 func (s *Symbol) SetDeclarations(value []*Node)   { s.data.declarations = value }
 func (s *Symbol) SetValueDeclaration(value *Node) { s.data.valueDeclaration = value }
-func (s *Symbol) SetMembers(value SymbolTable)    { s.data.members = value }
-func (s *Symbol) SetExports(value SymbolTable)    { s.data.exports = value }
 func (s *Symbol) SetParent(value *Symbol)         { s.data.parent = value }
-func (s *Symbol) SetExportSymbol(value *Symbol)   { s.data.exportSymbol = value }
+
+func (s *Symbol) ensureExtra(arena *SymbolExtraArena) *symbolExtra {
+	if s.data.extra == nil {
+		s.data.extra = arena.arena.New()
+	}
+	return s.data.extra
+}
+
+func (s *Symbol) SetMembers(value SymbolTable, arena *SymbolExtraArena) {
+	if value != nil || s.data.extra != nil {
+		s.ensureExtra(arena).members = value
+	}
+}
+
+func (s *Symbol) SetExports(value SymbolTable, arena *SymbolExtraArena) {
+	if value != nil || s.data.extra != nil {
+		s.ensureExtra(arena).exports = value
+	}
+}
+
+func (s *Symbol) SetExportSymbol(value *Symbol, arena *SymbolExtraArena) {
+	if value != nil || s.data.extra != nil {
+		s.ensureExtra(arena).exportSymbol = value
+	}
+}
 
 // SymbolWithData is a helper structure that contains both a Symbol and its associated symbolData.
 type SymbolWithData struct {

tsc/internal/ast/symbol_test.go

@@ -2,7 +2,9 @@ package ast_test
 
 import (
 	"reflect"
+	"runtime"
 	"testing"
+	"unsafe"
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"gotest.tools/v3/assert"
@@ -17,6 +19,7 @@ func TestSymbolFieldsArePrivate(t *testing.T) {
 
 func TestSymbolAccessors(t *testing.T) {
 	t.Parallel()
+	var arena ast.SymbolExtraArena
 	symbol := ast.NewSymbol()
 	assert.Equal(t, symbol.Flags(), ast.SymbolFlagsNone)
 	assert.Equal(t, symbol.CheckFlags(), ast.CheckFlags(0))
@@ -43,10 +46,10 @@ func TestSymbolAccessors(t *testing.T) {
 	symbol.SetName("C")
 	symbol.SetDeclarations(declarations)
 	symbol.SetValueDeclaration(declaration)
-	symbol.SetMembers(members)
-	symbol.SetExports(exports)
+	symbol.SetMembers(members, &arena)
+	symbol.SetExports(exports, &arena)
 	symbol.SetParent(parent)
-	symbol.SetExportSymbol(exportSymbol)
+	symbol.SetExportSymbol(exportSymbol, &arena)
 
 	assert.Equal(t, symbol.Flags(), ast.SymbolFlagsClass|ast.SymbolFlagsTransient)
 	assert.Equal(t, symbol.CheckFlags(), ast.CheckFlagsReadonly)
@@ -72,10 +75,10 @@ func TestSymbolAccessors(t *testing.T) {
 	symbol.SetName("")
 	symbol.SetDeclarations(nil)
 	symbol.SetValueDeclaration(nil)
-	symbol.SetMembers(nil)
-	symbol.SetExports(nil)
+	symbol.SetMembers(nil, &arena)
+	symbol.SetExports(nil, &arena)
 	symbol.SetParent(nil)
-	symbol.SetExportSymbol(nil)
+	symbol.SetExportSymbol(nil, &arena)
 
 	assert.Equal(t, symbol.Flags(), ast.SymbolFlagsNone)
 	assert.Equal(t, symbol.CheckFlags(), ast.CheckFlags(0))
@@ -90,24 +93,76 @@ func TestSymbolAccessors(t *testing.T) {
 
 func TestSymbolTableInitialization(t *testing.T) {
 	t.Parallel()
+	var arena ast.SymbolExtraArena
 	symbol := ast.NewSymbol()
 	member := ast.NewSymbol()
 	export := ast.NewSymbol()
 
-	members := ast.GetMembers(symbol)
+	members := ast.GetMembers(symbol, &arena)
 	members["member"] = member
 	assert.Equal(t, symbol.Members()["member"], member)
-	assert.Equal(t, ast.GetMembers(symbol)["member"], member)
+	assert.Equal(t, ast.GetMembers(symbol, &arena)["member"], member)
 
-	exports := ast.GetExports(symbol)
+	exports := ast.GetExports(symbol, &arena)
 	exports["export"] = export
 	assert.Equal(t, symbol.Exports()["export"], export)
-	assert.Equal(t, ast.GetExports(symbol)["export"], export)
+	assert.Equal(t, ast.GetExports(symbol, &arena)["export"], export)
 
-	symbol.SetMembers(nil)
-	symbol.SetExports(nil)
-	assert.Assert(t, ast.GetMembers(symbol) != nil)
-	assert.Assert(t, ast.GetExports(symbol) != nil)
+	symbol.SetMembers(nil, &arena)
+	symbol.SetExports(nil, &arena)
+	assert.Assert(t, ast.GetMembers(symbol, &arena) != nil)
+	assert.Assert(t, ast.GetExports(symbol, &arena) != nil)
 	assert.Equal(t, len(symbol.Members()), 0)
 	assert.Equal(t, len(symbol.Exports()), 0)
 }
+
+func TestSymbolHotRecordLayout(t *testing.T) {
+	t.Parallel()
+	assert.Equal(t, unsafe.Sizeof(ast.SymbolWithData{}), unsafe.Sizeof(ast.Symbol{})+8*unsafe.Sizeof((*ast.Node)(nil)))
+}
+
+func TestSymbolNilExtraFieldsDoNotAllocate(t *testing.T) { //nolint:paralleltest
+	var arena ast.SymbolExtraArena
+	symbol := ast.NewSymbol()
+	allocs := testing.AllocsPerRun(10, func() {
+		symbol.SetMembers(nil, &arena)
+		symbol.SetExports(nil, &arena)
+		symbol.SetExportSymbol(nil, &arena)
+	})
+	assert.Equal(t, allocs, float64(0))
+	assert.Assert(t, reflect.ValueOf(symbol).Elem().FieldByName("data").Elem().FieldByName("extra").IsNil())
+}
+
+func TestSymbolSharedExtraData(t *testing.T) {
+	t.Parallel()
+	var arena ast.SymbolExtraArena
+	var otherArena ast.SymbolExtraArena
+	symbol := ast.NewSymbol()
+	alias := ast.NewSymbol()
+	alias.SetSymbolData(symbol)
+	member := ast.NewSymbol()
+	export := ast.NewSymbol()
+	alias.SetMembers(ast.SymbolTable{"member": member}, &arena)
+	symbol.SetExports(ast.SymbolTable{"export": export}, &otherArena)
+	alias.SetExportSymbol(export, &otherArena)
+	runtime.GC()
+	assert.Equal(t, symbol.Members()["member"], member)
+	assert.Equal(t, alias.Exports()["export"], export)
+	assert.Equal(t, symbol.ExportSymbol(), export)
+	symbol.SetMembers(nil, &otherArena)
+	alias.SetExports(nil, &arena)
+	symbol.SetExportSymbol(nil, &arena)
+	assert.Assert(t, alias.Members() == nil)
+	assert.Assert(t, symbol.Exports() == nil)
+	assert.Assert(t, alias.ExportSymbol() == nil)
+	ast.GetMembers(alias, &otherArena)["new"] = export
+	ast.GetExports(symbol, &arena)["new"] = member
+	for range 1024 {
+		ast.NewSymbol().SetExports(ast.SymbolTable{"export": export}, &arena)
+	}
+	arena = ast.SymbolExtraArena{}
+	otherArena = ast.SymbolExtraArena{}
+	runtime.GC()
+	assert.Equal(t, symbol.Members()["new"], export)
+	assert.Equal(t, alias.Exports()["new"], member)
+}

tsc/internal/ast/utilities.go

@@ -99,12 +99,12 @@ func GetSymbolTable(data *SymbolTable) SymbolTable {
 	return *data
 }
 
-func GetMembers(symbol *Symbol) SymbolTable {
-	return GetSymbolTable(&symbol.data.members)
+func GetMembers(symbol *Symbol, arena *SymbolExtraArena) SymbolTable {
+	return GetSymbolTable(&symbol.ensureExtra(arena).members)
 }
 
-func GetExports(symbol *Symbol) SymbolTable {
-	return GetSymbolTable(&symbol.data.exports)
+func GetExports(symbol *Symbol, arena *SymbolExtraArena) SymbolTable {
+	return GetSymbolTable(&symbol.ensureExtra(arena).exports)
 }
 
 func GetLocals(container *Node) SymbolTable {