tricu

browser.mjs (4559B)

---

 import assert from 'node:assert/strict';
 import {spawn} from 'node:child_process';
 import {createServer} from 'node:http';
 import {readFile,mkdtemp,rm,writeFile} from 'node:fs/promises';
 import {tmpdir} from 'node:os';
 import {resolve,extname,sep} from 'node:path';
 const root=resolve('.');
 const server=createServer(async(req,res)=>{
   try {
     const path=new URL(req.url,'http://localhost').pathname;
     if(path==='/'){res.setHeader('Content-Type','text/html');res.end('<!doctype html><title>WASM experiment</title>');return;}
     const file=path==='/arboricx.wasm'?process.argv[2]:resolve(root,'.'+path);
     if(path!=='/arboricx.wasm'&&!file.startsWith(root+sep))throw new Error('outside root');
     res.setHeader('Content-Type',({'.mjs':'text/javascript','.js':'text/javascript','.wasm':'application/wasm','.json':'application/json'})[extname(file)]??'application/octet-stream');
     res.end(await readFile(file));
   } catch {res.writeHead(404);res.end();}
 });
 await new Promise(r=>server.listen(0,'127.0.0.1',r));
 const url=`http://127.0.0.1:${server.address().port}/`;
 const profile = await mkdtemp(resolve(tmpdir(), 'tricu-demo-chromium-'));
 let browser, socket;
 let next = 0; const pending = new Map();
 try {
   browser = spawn(process.argv[3] || 'chromium', ['--headless', '--no-sandbox', '--disable-dev-shm-usage',
     '--js-flags=--max-old-space-size=768', '--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank'], { stdio: ['ignore', 'ignore', 'pipe'] });
   const debuggerURL = await new Promise((resolve, reject) => {
     let stderr = '';
     const timer = setTimeout(() => reject(new Error('Chromium startup timed out: ' + stderr)), 15_000);
     browser.on('error', error => { clearTimeout(timer); reject(error); });
     browser.on('exit', code => { clearTimeout(timer); reject(new Error('Chromium exited: ' + code + '\n' + stderr)); });
     browser.stderr.on('data', chunk => {
       stderr += chunk;
       const match = stderr.match(/DevTools listening on (ws:\/\/\S+)/);
       if (match) { clearTimeout(timer); resolve(match[1]); }
     });
   });
   const endpoint = new URL(debuggerURL);
   const tab = await (await fetch(`http://${endpoint.host}/json/new?${encodeURIComponent(url)}`, { method: 'PUT' })).json();
   socket = new WebSocket(tab.webSocketDebuggerUrl);
   await new Promise((resolve, reject) => { socket.onopen = resolve; socket.onerror = reject; });
   const exceptions = [];
   socket.onmessage = ({ data }) => {
     const event = JSON.parse(data);
     if (event.id) {
       const waiter = pending.get(event.id); pending.delete(event.id);
       if (!waiter) return;
       clearTimeout(waiter.timer);
       if (event.error) waiter.reject(new Error(JSON.stringify(event.error)));
       else waiter.resolve(event.result);
     } else if (event.method === 'Runtime.exceptionThrown') exceptions.push(event.params);
   };
   const send = (method, params = {}) => new Promise((resolve, reject) => {
     const id = ++next;
     const timer = setTimeout(() => { pending.delete(id); reject(new Error('CDP timed out: ' + method)); }, 180_000);
     pending.set(id, { resolve, reject, timer });
     socket.send(JSON.stringify({ id, method, params }));
   });
   await send('Runtime.enable'); await send('Page.enable');
   const evaluate = async expression => {
     const result = await send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true });
     if (result.exceptionDetails) throw new Error(JSON.stringify(result.exceptionDetails));
     return result.result.value;
   };
   const report=await evaluate("import('/ext/wasm/browser-page.mjs').then(m=>m.run())");
   assert.equal(report.samples.length,24);
   assert.deepEqual(exceptions,[]);
   await writeFile(process.argv[4],JSON.stringify(report,null,2)+'\n');
   for(const index of [0,1,2,3]) {
     const median=host=>report.samples.filter(s=>s.host===host&&s.case===index).map(s=>s.compileMs).sort((a,b)=>a-b)[1];
     console.log(`browser compiler-${index}: JS ${median('js').toFixed(1)} ms; WASM ${median('wasm').toFixed(1)} ms`);
   }
   console.log(report.controls.join('\n'));
 } finally {
   for (const waiter of pending.values()) { clearTimeout(waiter.timer); waiter.reject(new Error('Browser test closed')); }
   pending.clear(); socket?.close();
   if (browser && browser.exitCode === null) {
     const exited = new Promise(resolve => browser.once('exit', resolve));
     browser.kill('SIGKILL'); await exited;
   }
   await new Promise(resolve => server.close(resolve));
   await rm(profile, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
 }