Diffusion Ant (bytecode) Code

ant/tests/bench_gc.js
da28911c0817bytecode

bench_gc.js
View Options

			// GC Benchmark - tests forwarding table and compaction performance

			function formatBytes(bytes) {
			if (bytes < 1024) return bytes + ' B';
			if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + ' KB';
			return (bytes / 1024 / 1024).toFixed(2) + ' MB';
			}

			function bench(name, fn, iterations = 1) {
			// Warmup
			fn();
			Ant.gc();

			let totalTime = 0;
			let totalFreed = 0;

			for (let iter = 0; iter < iterations; iter++) {
			fn(); // Create garbage

			const t0 = Date.now();
			const result = Ant.gc();
			const elapsed = Date.now() - t0;

			totalTime += elapsed;
			totalFreed += result.arenaFreed;
			}

			console.log(`${name}:`);
			console.log(` Time: ${totalTime}ms (${iterations} iterations, avg ${(totalTime / iterations).toFixed(2)}ms)`);
			console.log(` Freed: ${formatBytes(totalFreed)} total`);
			console.log('');
			}

			// Test 1: Many small objects (stresses forwarding table with many entries)
			function manySmallObjects() {
			const objects = [];
			for (let i = 0; i < 1000; i++) {
			objects.push({ id: i, value: i * 2 });
			}
			// Let half become garbage
			objects.length = 5000;
			}

			// Test 2: Deep object graph (stresses recursive copying)
			function deepObjectGraph() {
			let obj = { value: 0 };
			for (let i = 1; i < 1000; i++) {
			obj = { value: i, child: obj };
			}
			return obj;
			}

			// Test 3: Wide object (many properties)
			function wideObject() {
			const obj = {};
			for (let i = 0; i < 1000; i++) {
			obj['prop' + i] = i;
			}
			return obj;
			}

			// Test 4: Array of strings (tests string copying)
			function stringArray() {
			const arr = [];
			for (let i = 0; i < 5000; i++) {
			arr.push('string_value_' + i + '_with_some_extra_content');
			}
			arr.length = 2500; // Half become garbage
			}

			// Test 5: Mixed workload
			function mixedWorkload() {
			const data = {
			objects: [],
			strings: [],
			nested: null
			};

			for (let i = 0; i < 2000; i++) {
			data.objects.push({ x: i, y: i * 2, name: 'obj' + i });
			data.strings.push('item_' + i);
			}

			// Create some nested structure
			let nested = { level: 0 };
			for (let i = 1; i < 100; i++) {
			nested = { level: i, prev: nested, data: { a: i, b: i * 2 } };
			}
			data.nested = nested;

			// Make some garbage
			data.objects.length = 1000;
			data.strings.length = 1000;
			}

			// Test 6: Repeated GC cycles (tests table reuse efficiency)
			function repeatedGcCycles() {
			for (let cycle = 0; cycle < 10; cycle++) {
			const temp = [];
			for (let i = 0; i < 1000; i++) {
			temp.push({ cycle, i, data: 'x'.repeat(50) });
			}
			}
			}

			console.log('=== GC Benchmark ===\n');
			console.log('Initial state:', Ant.alloc(), '\n');

			bench('Many small objects (10k objects, 5k garbage)', manySmallObjects, 5);
			bench('Deep object graph (1000 levels)', deepObjectGraph, 5);
			bench('Wide object (1000 properties)', wideObject, 5);
			bench('String array (5000 strings, 2500 garbage)', stringArray, 5);
			bench('Mixed workload', mixedWorkload, 5);
			bench('Repeated GC cycles (10 cycles x 1000 objects)', repeatedGcCycles, 3);

			console.log('Final state:', Ant.alloc());

Owner Packages

No Owners