perf: increase parse speed ~10% by increasing initial arena size (#80)

Closes #75

Author: bartveneman

src/arena.test.ts

@@ -1,5 +1,7 @@
 import { describe, test, expect } from 'vitest'
+import { readFileSync } from 'fs'
 import { CSSDataArena, STYLESHEET, STYLE_RULE, DECLARATION, FLAG_IMPORTANT, FLAG_HAS_ERROR } from './arena'
+import { parse } from './parse'
 
 describe('CSSDataArena', () => {
 	describe('initialization', () => {
@@ -237,34 +239,99 @@ describe('CSSDataArena', () => {
 		})
 	})
 
-	describe('capacity planning', () => {
-		test('should have minimum capacity for empty files', () => {
-			const capacity = CSSDataArena.capacity_for_source(0)
-			expect(capacity).toBe(16)
+	describe('growth tracking', () => {
+		test('should initialize growth count to zero', () => {
+			const arena = new CSSDataArena()
+			expect(arena.get_growth_count()).toBe(0)
+		})
+
+		test('should track single growth event', () => {
+			const arena = new CSSDataArena(2)
+			expect(arena.get_growth_count()).toBe(0)
+
+			// Create nodes to trigger growth
+			arena.create_node(STYLESHEET, 0, 0, 1, 1) // count = 2
+			expect(arena.get_growth_count()).toBe(0)
+
+			arena.create_node(STYLESHEET, 0, 0, 1, 1) // count = 3, triggers growth
+			expect(arena.get_growth_count()).toBe(1)
+		})
+
+		test('should track multiple growth events', () => {
+			const arena = new CSSDataArena(2)
+			expect(arena.get_growth_count()).toBe(0)
+
+			// First growth: 2 -> 3
+			arena.create_node(STYLESHEET, 0, 0, 1, 1)
+			arena.create_node(STYLESHEET, 0, 0, 1, 1)
+			expect(arena.get_growth_count()).toBe(1)
+			expect(arena.get_capacity()).toBe(3) // ceil(2 * 1.3) = 3
+
+			// Second growth: 3 -> 4
+			arena.create_node(STYLESHEET, 0, 0, 1, 1)
+			expect(arena.get_growth_count()).toBe(2)
+			expect(arena.get_capacity()).toBe(4) // ceil(3 * 1.3) = 4
+
+			// Third growth: 4 -> 6
+			arena.create_node(STYLESHEET, 0, 0, 1, 1)
+			expect(arena.get_growth_count()).toBe(3)
+			expect(arena.get_capacity()).toBe(6) // ceil(4 * 1.3) = 6
 		})
 
-		test('should calculate capacity for small CSS files', () => {
-			// 1KB CSS = 60 nodes * 1.15 buffer = 69 nodes
-			const capacity = CSSDataArena.capacity_for_source(1024)
-			expect(capacity).toBe(69)
+		test('should not increment growth count when capacity is sufficient', () => {
+			const arena = new CSSDataArena(100)
+
+			// Create many nodes without exceeding capacity
+			for (let i = 0; i < 50; i++) {
+				arena.create_node(STYLESHEET, 0, 0, 1, 1)
+			}
+
+			expect(arena.get_growth_count()).toBe(0)
+			expect(arena.get_count()).toBe(51) // 50 created + 1 initial
 		})
+	})
 
-		test('should calculate capacity for medium CSS files', () => {
-			// 100KB CSS = 6000 nodes * 1.15 buffer = 6900 nodes
-			const capacity = CSSDataArena.capacity_for_source(100 * 1024)
-			expect(capacity).toBe(6900)
+	describe('real-world CSS frameworks', () => {
+		test('should not grow for Bootstrap CSS', () => {
+			const css = readFileSync('node_modules/bootstrap/dist/css/bootstrap.css', 'utf-8')
+			const result = parse(css)
+
+			expect(result.__get_arena().get_growth_count()).toBe(0)
+			const utilization = (result.__get_arena().get_count() / result.__get_arena().get_capacity()) * 100
+			expect(utilization).toBeLessThan(85)
+			expect(utilization).toBeGreaterThan(30)
 		})
 
-		test('should calculate capacity for large CSS files', () => {
-			// 10MB = 10240 KB CSS = 614400 nodes * 1.15 buffer = 706560 nodes
-			const capacity = CSSDataArena.capacity_for_source(10 * 1024 * 1024)
-			expect(capacity).toBe(706560)
+		test('should not grow for Bootstrap minified CSS', () => {
+			const css = readFileSync('node_modules/bootstrap/dist/css/bootstrap.min.css', 'utf-8')
+			const result = parse(css)
+			const arena = result.__get_arena()
+
+			expect(arena.get_growth_count()).toBe(0)
+			const utilization = (arena.get_count() / arena.get_capacity()) * 100
+			expect(utilization).toBeLessThan(85)
+			expect(utilization).toBeGreaterThan(30)
 		})
 
-		test('should round up for partial KBs', () => {
-			// 1.5KB = ceil(1.5 * 60) * 1.15 = 90 * 1.15 = 104 (rounded up)
-			const capacity = CSSDataArena.capacity_for_source(1536)
-			expect(capacity).toBe(104)
+		test('should not grow for Tailwind CSS', () => {
+			const css = readFileSync('node_modules/tailwindcss/dist/tailwind.css', 'utf-8')
+			const result = parse(css)
+			const arena = result.__get_arena()
+
+			expect(arena.get_growth_count()).toBe(0)
+			const utilization = (arena.get_count() / arena.get_capacity()) * 100
+			expect(utilization).toBeLessThan(85)
+			expect(utilization).toBeGreaterThan(30)
+		})
+
+		test('should not grow for Tailwind minified CSS', () => {
+			const css = readFileSync('node_modules/tailwindcss/dist/tailwind.min.css', 'utf-8')
+			const result = parse(css)
+
+			expect(result.__get_arena().get_growth_count()).toBe(0)
+			const utilization = (result.__get_arena().get_count() / result.__get_arena().get_capacity()) * 100
+			expect(utilization).toBeLessThan(85)
+			expect(utilization).toBeGreaterThan(30)
 		})
 	})
 })

src/arena.ts

@@ -118,20 +118,22 @@ export class CSSDataArena {
 	private view: DataView
 	private capacity: number // Number of nodes that can fit
 	private count: number // Number of nodes currently allocated
+	private growth_count: number // Number of times the arena has grown
 
 	// Growth multiplier when capacity is exceeded
 	private static readonly GROWTH_FACTOR = 1.3
 
 	// Estimated nodes per KB of CSS (based on real-world data)
-	private static readonly NODES_PER_KB = 60
+	private static readonly NODES_PER_KB = 270
 
 	// Buffer to avoid frequent growth (15%)
-	private static readonly CAPACITY_BUFFER = 1.15
+	private static readonly CAPACITY_BUFFER = 1.2
 
 	constructor(initial_capacity: number = 1024) {
 		this.capacity = initial_capacity
 		// Start count at 1 since 0 is reserved for "no node"
 		this.count = 1
+		this.growth_count = 0
 		this.buffer = new ArrayBuffer(initial_capacity * BYTES_PER_NODE)
 		this.view = new DataView(this.buffer)
 	}
@@ -156,6 +158,11 @@ export class CSSDataArena {
 		return this.capacity
 	}
 
+	// Get the number of times the arena has grown
+	get_growth_count(): number {
+		return this.growth_count
+	}
+
 	// Calculate byte offset for a node
 	private node_offset(node_index: number): number {
 		return node_index * BYTES_PER_NODE
@@ -311,6 +318,7 @@ export class CSSDataArena {
 
 	// Grow the arena by 1.3x when capacity is exceeded
 	private grow(): void {
+		this.growth_count++
 		let new_capacity = Math.ceil(this.capacity * CSSDataArena.GROWTH_FACTOR)
 		let new_buffer = new ArrayBuffer(new_capacity * BYTES_PER_NODE)
 
@@ -325,13 +333,7 @@ export class CSSDataArena {
 
 	// Allocate and initialize a new node with core properties
 	// Automatically grows the arena if capacity is exceeded
-	create_node(
-		type: number,
-		start_offset: number,
-		length: number,
-		start_line: number,
-		start_column: number
-	): number {
+	create_node(type: number, start_offset: number, length: number, start_line: number, start_column: number): number {
 		if (this.count >= this.capacity) {
 			this.grow()
 		}

src/css-node.ts

@@ -187,6 +187,11 @@ export class CSSNode {
 		this.index = index
 	}
 
+	/** Get the arena (for internal/advanced use only) */
+	__get_arena(): CSSDataArena {
+		return this.arena
+	}
+
 	/** Get node type as number (for performance) */
 	get type(): CSSNodeType {
 		return this.arena.get_type(this.index) as CSSNodeType

tsconfig.json

@@ -9,7 +9,7 @@
 		"resolveJsonModule": true,
 		"isolatedModules": true,
 		"noEmit": true,
-		"types": ["vitest/globals"]
+		"types": ["vitest/globals", "node"]
 	},
 	"include": ["src/**/*"],
 	"exclude": ["node_modules", "dist", "benchmark"]