tricu

backend-benchmark.mjs (4712B)

---

 // Matched production Worker benchmark. No evaluator instrumentation or GC tuning.
 export async function run(control,backend,memoryOnly=false){
  const base=new URL('../',document.querySelector('script[type=module][src]').src);
  const [fixtures,catalogue,{Graph},{view}]=await Promise.all([
   fetch('/zig-fixtures.json').then(r=>r.json()),fetch(new URL('catalogue.json',base)).then(r=>r.json()),
   import(new URL('dist/probe-api.js',base)).then(m=>m.graph),import(new URL('dist/probe-api.js',base)).then(m=>m.codecs),
  ]);
  const assert=(ok,message)=>{if(!ok)throw Error(message);};
  const mark=async name=>{await fetch(control+'/phase',{method:'POST',body:JSON.stringify({name})});};
  const pause=ms=>new Promise(r=>setTimeout(r,ms));
  const report={schema:1,backend,memoryOnly,userAgent:navigator.userAgent,packages:[],compilations:[],checks:['production Worker replies checked against independent Haskell goldens'],scope:'Fresh profile; localhost uncompressed/no-store HTTP; first package includes cold runtime startup; later Workers may benefit from engine module caches. Compilation includes initialization/authentication/environment loading. Runs include full selected-codec observation and Worker messaging. No user think-time or forced GC.'};
  function client(){
   const worker=new Worker(new URL('dist/wasm-worker.js?backend='+backend,base),{type:'module'});
   let pending;
   worker.onerror=e=>{pending?.reject(Error(e.message));pending=undefined;};
   worker.onmessage=({data:m})=>{
    if(!pending)return;
    if(m.type==='error'){pending.reject(Error(m.message));pending=undefined;return;}
    if(m.type==='output')pending.terminal+=m.text;
    if(m.type==='state'&&m.state==='input')worker.postMessage({type:'resume',id:m.id,value:pending.input});
    if(m.type===pending.expected){pending.resolve({message:m,terminal:pending.terminal,ms:performance.now()-pending.start});pending=undefined;}
   };
   return {request(message,expected,input=''){assert(!pending,'Overlapping benchmark request');return new Promise((resolve,reject)=>{pending={resolve,reject,expected,input,terminal:'',start:performance.now()};worker.postMessage(message);});},dispose(){worker.terminate();}};
  }
  const cases=Object.entries(fixtures.demos).map(([name,demo])=>{
   const entry=catalogue.find(e=>e.hash===demo.hash),c=demo.haskellCases[0];assert(entry,'Missing fixture catalogue entry');
   const output=entry.presets?.[c.export]?.output??entry.output;
   const graph=new Graph(),expected=view(graph,graph.fromTernary(c.result),output);
   assert(output!=='tree'&&output!=='list','Benchmark requires complete scalar/record observation');
   return {name,demo,entry,c,output,expected};
  });
  await mark('baseline');await pause(memoryOnly?3000:700);
  for(const {name,demo,entry,c,output,expected} of cases){
   await mark('package:'+name);const start=performance.now(),w=client();
   try{
    await w.request({type:'load',hash:demo.hash,localId:name},'loaded');const readyMs=performance.now()-start;
    const result=await w.request({type:'run',export:c.export,arguments:c.arguments.map(value=>({type:'tree',value})),output,mode:demo.mode},'done',c.input??'');
    assert(JSON.stringify(result.message.result)===JSON.stringify(expected),'Published result '+name);
    assert(result.terminal===c.terminal,'Published terminal '+name);
    report.packages.push({name,readyMs,runMs:result.ms,linearBytes:result.message.stats.linearMemoryBytes});
    if(memoryOnly){await mark('live-package:'+name);await pause(1500);}
   }finally{w.dispose();}
   await mark('package-disposed:'+name);await pause(120);
  }
  for(const {name,demo,entry,c,output,expected} of cases){
   await mark('compile:'+name);const start=performance.now(),w=client();
   try{
    const compiled=await w.request({type:'compile',source:demo.source,environment:entry.environment},'compiled');
    const row={name,readyMs:performance.now()-start,workerCompileMs:compiled.message.milliseconds,compileLinearBytes:compiled.message.stats.linearMemoryBytes,runs:[]};
    await mark('runs:'+name);
    for(let i=0;i<21;i++){
     const r=await w.request({type:'run',export:c.export,arguments:c.arguments.map(value=>({type:'tree',value})),output,mode:demo.mode},'done',c.input??'');
     assert(JSON.stringify(r.message.result)===JSON.stringify(expected),'Compiled result '+name);
     assert(r.terminal===c.terminal,'Compiled terminal '+name);
     row.runs.push({ms:r.ms,linearBytes:r.message.stats.linearMemoryBytes});
    }
    report.compilations.push(row);
    if(memoryOnly){await mark('live-compiled:'+name);await pause(1500);}
   }finally{w.dispose();}
   await mark('compile-disposed:'+name);await pause(150);
  }
  await mark('final-idle');await pause(1500);await mark('finished');
  return report;
 }