Update app.py

app.py

@@ -83,6 +83,30 @@ async () => {
   let previousUrls = [];
   function setLog(message) { $("sam-log").textContent = message; }
   function setStatus(message) { $("sam-status").textContent = message; }
+  function diagnosticEnvironment(provider) {
+    const runtime = ort;
+    const isolated = window.crossOriginIsolated === true;
+    const sharedArrayBuffer = typeof SharedArrayBuffer !== "undefined";
+    const requestedThreads = runtime?.env?.wasm?.numThreads ?? "not initialized";
+    const proxy = runtime?.env?.wasm?.proxy ?? "not initialized";
+    const report = {
+      browser: navigator.userAgent,
+      hardwareConcurrency: navigator.hardwareConcurrency ?? "unknown",
+      crossOriginIsolated: isolated,
+      sharedArrayBufferAvailable: sharedArrayBuffer,
+      wasmMultithreadingLikelyAvailable: isolated && sharedArrayBuffer,
+      provider,
+      wasmThreadsRequested: requestedThreads,
+      wasmProxyWorker: proxy,
+      note: isolated && sharedArrayBuffer
+        ? "WASM multithreading prerequisites appear available; actual thread use depends on ONNX Runtime/browser support."
+        : "WASM multithreading is likely unavailable because cross-origin isolation or SharedArrayBuffer is missing."
+    };
+    return report;
+  }
+  function logDiagnostic(label, details) {
+    console.info("[SAM Audio diagnostics] " + label, details);
+  }
   function errorDetails(error) {
     const values = [];
     for (const key of ["name", "message", "code", "stack"]) {
@@ -187,6 +211,9 @@ async () => {
         runtime.env.wasm.numThreads = 0; // automatic, subject to browser support
       }
       runtimeProvider = provider;
+      const diagnostics = diagnosticEnvironment(provider);
+      logDiagnostic("Runtime configured", diagnostics);
+      setLog("Runtime diagnostics\n" + JSON.stringify(diagnostics, null, 2));
     }
     return runtime;
   }
@@ -332,7 +359,14 @@ async () => {
       maskDims: [1, mask.length]
     };
   }
+  const stageMetrics = {};
+  function addMetric(name, milliseconds) {
+    if (!stageMetrics[name]) stageMetrics[name] = {totalMs: 0, calls: 0};
+    stageMetrics[name].totalMs += milliseconds;
+    stageMetrics[name].calls += 1;
+  }
   async function runDit(noisy, timeValue, audioFeatures, text, sequenceLength) {
+    const started = performance.now();
     const batch = 1;
     const zerosInt = new BigInt64Array(sequenceLength);
     const mask = new Uint8Array(sequenceLength).fill(1);
@@ -350,9 +384,11 @@ async () => {
     };
     const outputs = await sessions.dit.run(feeds);
     const tensor = outputs.velocity || outputs[sessions.dit.outputNames[0]];
+    addMetric("DiT session.run", performance.now() - started);
     return new Float32Array(tensor.data);
   }
   async function runOde(initial, audioFeatures, text, steps, sequenceLength) {
+    const started = performance.now();
     let x = new Float32Array(initial);
     const dt = 1 / steps;
     for (let i = 0; i < steps; i++) {
@@ -368,9 +404,11 @@ async () => {
       // Yield so status/progress updates can paint between long CPU steps.
       await new Promise(resolve => setTimeout(resolve, 0));
     }
+    addMetric("ODE denoising total", performance.now() - started);
     return x;
   }
   async function decodeLatent(latent, latentChannels, timeSteps) {
+    const started = performance.now();
     const session = sessions.decoder;
     const chunkSize = 25;
     const hopLength = 1920;
@@ -396,6 +434,7 @@ async () => {
     const output = new Float32Array(totalLength);
     let offset = 0;
     for (const chunk of chunks) { output.set(chunk, offset); offset += chunk.length; }
+    addMetric("Decoder total", performance.now() - started);
     return output;
   }
   function wavBlob(samples, sampleRate) {
@@ -433,20 +472,28 @@ async () => {
     const expectedSamples = audio.samples.length;
     if (expectedSamples > 48000 * 20) throw new Error("For this first prototype, use audio no longer than 20 seconds.");
     setStatus("Loading models for " + deviceLabel + "…");
+    const totalStartedAt = performance.now();
+    const modelLoadStartedAt = performance.now();
     if (provider === "wasm") {
       setLog("CPU mode selected. ONNX Runtime will use WebAssembly in a background worker where supported, keeping the page responsive. This may take longer than GPU inference.");
     }
     await loadModels(provider);
+    const modelLoadMs = performance.now() - modelLoadStartedAt;
+    for (const key of Object.keys(stageMetrics)) delete stageMetrics[key];
     const startedAt = performance.now();
     setStatus("Encoding audio on " + deviceLabel + "…");
+    const encoderStartedAt = performance.now();
     const encoded = await encodeAudio(audio.samples);
+    const encoderMs = performance.now() - encoderStartedAt;
     if (encoded.dims.length !== 3) throw new Error("Unexpected encoder output dimensions: " + JSON.stringify(encoded.dims));
     const [batch, latentChannels, timeSteps] = encoded.dims;
     if (batch !== 1 || latentChannels !== 128) {
       throw new Error("Unexpected audio latent shape " + JSON.stringify(encoded.dims) + "; expected [1, 128, time].");
     }
     setStatus("Encoding text…");
+    const textStartedAt = performance.now();
     const text = await encodeText(prompt);
+    const textMs = performance.now() - textStartedAt;
     const mixture = new Float32Array(timeSteps * 256);
     for (let t = 0; t < timeSteps; t++) {
       for (let c = 0; c < latentChannels; c++) {
@@ -474,21 +521,44 @@ async () => {
       }
     }
     setStatus("Decoding target…");
+    const targetStartedAt = performance.now();
     const target = await decodeLatent(targetLatent, latentChannels, timeSteps);
+    const targetDecodeMs = performance.now() - targetStartedAt;
     setStatus("Decoding residual…");
+    const residualStartedAt = performance.now();
     const residual = await decodeLatent(residualLatent, latentChannels, timeSteps);
+    const residualDecodeMs = performance.now() - residualStartedAt;
     if (audio.samples.length !== expectedSamples) {
       throw new Error("Internal audio buffer was unexpectedly detached or resized: expected " + expectedSamples + " samples, got " + audio.samples.length + ".");
     }
     showOutput("sam-target-player", "sam-target-download", target.slice(0, expectedSamples), 48000, "target.wav");
     showOutput("sam-residual-player", "sam-residual-download", residual.slice(0, expectedSamples), 48000, "residual.wav");
     setStatus("Finished");
+    const runtimeDiagnostics = diagnosticEnvironment(provider);
+    const stageTimings = {
+      modelLoadingSeconds: +(modelLoadMs / 1000).toFixed(2),
+      audioEncoderSeconds: +(encoderMs / 1000).toFixed(2),
+      textEncoderIncludingTokenizerSeconds: +(textMs / 1000).toFixed(2),
+      denoisingTotalSeconds: +((stageMetrics["ODE denoising total"]?.totalMs || 0) / 1000).toFixed(2),
+      ditSessionRunSeconds: +((stageMetrics["DiT session.run"]?.totalMs || 0) / 1000).toFixed(2),
+      ditCalls: stageMetrics["DiT session.run"]?.calls || 0,
+      averageDitCallSeconds: stageMetrics["DiT session.run"]?.calls
+        ? +((stageMetrics["DiT session.run"].totalMs / stageMetrics["DiT session.run"].calls) / 1000).toFixed(3) : 0,
+      targetDecoderSeconds: +(targetDecodeMs / 1000).toFixed(2),
+      residualDecoderSeconds: +(residualDecodeMs / 1000).toFixed(2),
+      inferenceAfterModelsSeconds: +((performance.now() - startedAt) / 1000).toFixed(2),
+      totalSecondsIncludingModelLoad: +((performance.now() - totalStartedAt) / 1000).toFixed(2)
+    };
+    const diagnosticsText = "Runtime diagnostics\n" + JSON.stringify(runtimeDiagnostics, null, 2) +
+      "\n\nStage timings\n" + JSON.stringify(stageTimings, null, 2);
+    logDiagnostic("Inference completed", {runtime: runtimeDiagnostics, timings: stageTimings});
     setLog("Finished browser inference.\nInput: " + file.name + "\nPrompt: " + prompt +
-      "\nDevice: " + deviceLabel + "\nProcessing time: " + ((performance.now() - startedAt) / 1000).toFixed(2) + " s" +
+      "\nDevice: " + deviceLabel + "\nProcessing time after model load: " + stageTimings.inferenceAfterModelsSeconds + " s" +
       "\nODE steps: " + steps + "\nInput samples: " + expectedSamples +
       "\nLatent shape: " + JSON.stringify(encoded.dims) +
       "\nTarget samples: " + Math.min(target.length, expectedSamples) +
       "\nResidual samples: " + Math.min(residual.length, expectedSamples) +
+      "\n\n" + diagnosticsText +
       "\n\nThis is an experimental port. Compare quality and tensor shapes against the Python reference before relying on results.");
   }
   $("sam-clear-cache").addEventListener("click", async () => {