Add env info into the ID

bench/src/core/benchmark-id.ts

@@ -8,6 +8,27 @@
  * 4. Are sortable and searchable
  */
 
+export interface EnvironmentInfo {
+  // Node.js format
+  cpu?: {
+    model?: string;
+    cores?: number;
+  };
+  memory?: {
+    total?: string;
+    deviceMemory?: number; // Web browser format (GB)
+  };
+  gpu?: {
+    vendor?: string;
+    renderer?: string;
+  };
+  platform?: string;
+  arch?: string;
+
+  // Web browser format (direct fields)
+  cpuCores?: number;
+}
+
 export interface BenchmarkSettings {
   platform: "node" | "web";
   modelId: string;
@@ -18,6 +39,7 @@ export interface BenchmarkSettings {
   batchSize?: number;
   browser?: string;
   headed?: boolean;
+  environment?: EnvironmentInfo;
 }
 
 /**
@@ -48,6 +70,17 @@ export function generateBenchmarkId(settings: BenchmarkSettings): string {
   return `${task}/${modelId}/${filenameParts.join("_")}`;
 }
 
+/**
+ * Sanitize environment strings for use in filenames
+ */
+function sanitizeEnvString(str: string): string {
+  return str
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9\-]/g, "")
+    .substring(0, 20); // Limit length
+}
+
 /**
  * Generate the filename parts (everything except task and model ID)
  */
@@ -88,6 +121,52 @@ function generateFilenameParts(settings: BenchmarkSettings): string[] {
     parts.push("headed");
   }
 
+  // 8. Environment info (CPU, memory, architecture, GPU)
+  if (settings.environment) {
+    const env = settings.environment;
+
+    // CPU model (sanitized, first significant part) - Node.js only
+    if (env.cpu?.model) {
+      const cpuName = sanitizeEnvString(env.cpu.model.split(/[\s(]/)[0]);
+      if (cpuName) {
+        parts.push(cpuName);
+      }
+    }
+
+    // CPU cores (support both Node.js and web browser formats)
+    const cores = env.cpu?.cores || env.cpuCores;
+    if (cores) {
+      parts.push(`${cores}c`);
+    }
+
+    // Memory (support both Node.js and web browser formats)
+    if (env.memory?.total) {
+      // Node.js format: Parse memory string like "32.00 GB" -> "32gb"
+      const memMatch = env.memory.total.match(/^(\d+)/);
+      if (memMatch) {
+        parts.push(`${memMatch[1]}gb`);
+      }
+    } else if (env.memory?.deviceMemory) {
+      // Web browser format: deviceMemory is already in GB
+      parts.push(`${env.memory.deviceMemory}gb`);
+    }
+
+    // Architecture (Node.js only, browser uses platform like "MacIntel")
+    if (env.arch) {
+      parts.push(env.arch);
+    }
+
+    // GPU vendor/renderer for web (if using webgpu)
+    if (settings.platform === "web" && settings.device === "webgpu" && env.gpu) {
+      if (env.gpu.vendor) {
+        const gpuVendor = sanitizeEnvString(env.gpu.vendor.split(/[\s(]/)[0]);
+        if (gpuVendor && gpuVendor !== "google") { // Skip "Google Inc."
+          parts.push(`gpu-${gpuVendor}`);
+        }
+      }
+    }
+  }
+
   return parts;
 }
 

bench/src/server/hf-dataset.ts

@@ -46,6 +46,14 @@ export class HFDatasetUploader {
       batchSize: benchmark.batchSize,
       browser: benchmark.browser,
       headed: benchmark.headed,
+      environment: benchmark.result?.environment ? {
+        cpu: benchmark.result.environment.cpu,
+        memory: benchmark.result.environment.memory,
+        gpu: benchmark.result.environment.gpu,
+        platform: benchmark.result.environment.platform,
+        arch: benchmark.result.environment.arch,
+        cpuCores: benchmark.result.environment.cpuCores, // Web browser format
+      } : undefined,
     };
 
     const { fullPath } = generateBenchmarkPath(settings);
@@ -53,6 +61,55 @@ export class HFDatasetUploader {
     return fullPath.replace(/\.jsonl$/, ".json");
   }
 
+  /**
+   * Transform benchmark data for HF Dataset upload
+   * Lifts frequently-accessed fields to top level for easier browsing
+   */
+  private transformForUpload(benchmark: QueuedBenchmark): any {
+    const result = benchmark.result || {};
+
+    return {
+      // Top-level metadata
+      id: benchmark.id,
+      status: benchmark.status,
+      timestamp: benchmark.timestamp,
+      startedAt: benchmark.startedAt,
+      completedAt: benchmark.completedAt,
+
+      // Configuration (lifted to top level)
+      platform: benchmark.platform,
+      modelId: benchmark.modelId,
+      task: benchmark.task,
+      mode: benchmark.mode,
+      device: benchmark.device,
+      dtype: benchmark.dtype,
+      batchSize: benchmark.batchSize,
+      repeats: benchmark.repeats,
+
+      // Browser-specific (only if web platform)
+      ...(benchmark.platform === "web" && {
+        browser: benchmark.browser,
+        headed: benchmark.headed,
+      }),
+
+      // Runtime info (lifted from result)
+      runtime: result.runtime,
+
+      // Metrics (lifted to top level for easy access)
+      metrics: result.metrics,
+
+      // Environment (lifted to top level for easy access)
+      environment: result.environment,
+
+      // Error info (if present)
+      ...(result.error && { error: result.error }),
+
+      // Additional metadata
+      ...(result.cacheDir && { cacheDir: result.cacheDir }),
+      ...(result.notes && { notes: result.notes }),
+    };
+  }
+
   /**
    * Upload a benchmark result to HF Dataset
    * Overwrites the file if it already exists
@@ -64,8 +121,9 @@ export class HFDatasetUploader {
 
     const filePath = this.getHFFilePath(benchmark);
 
-    // Convert benchmark to JSON string
-    const content = JSON.stringify(benchmark, null, 2);
+    // Transform and convert benchmark to JSON string
+    const transformed = this.transformForUpload(benchmark);
+    const content = JSON.stringify(transformed, null, 2);
     const blob = new Blob([content], { type: "application/json" });
 
     try {

bench/src/server/storage.ts

@@ -26,6 +26,14 @@ export class BenchmarkStorage {
       batchSize: benchmark.batchSize,
       browser: benchmark.browser,
       headed: benchmark.headed,
+      environment: benchmark.result?.environment ? {
+        cpu: benchmark.result.environment.cpu,
+        memory: benchmark.result.environment.memory,
+        gpu: benchmark.result.environment.gpu,
+        platform: benchmark.result.environment.platform,
+        arch: benchmark.result.environment.arch,
+        cpuCores: benchmark.result.environment.cpuCores, // Web browser format
+      } : undefined,
     };
 
     const { dir, filename } = generateBenchmarkPath(settings);