space fetch

.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+
+*.so
+*.out

Dockerfile

@@ -0,0 +1,26 @@
+FROM archlinux:latest
+
+# 安装系统依赖
+RUN pacman -Syu --noconfirm && \
+    pacman -S --noconfirm \
+    python python-pip \
+    base-devel \
+    openssl \
+    pciutils \
+    && pacman -Scc --noconfirm
+
+# 创建工作目录
+WORKDIR /app
+
+# 复制并安装 Python 依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt --break-system-packages
+
+# 复制应用代码
+COPY . .
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动应用
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,297 @@
+"""
+Space Fetch - System Performance Dashboard
+FastAPI 主应用入口
+"""
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import Dict, Any, Optional
+
+import uvicorn
+from fastapi import FastAPI, BackgroundTasks
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, JSONResponse
+from pydantic import BaseModel
+
+from benchmarks.system_info import get_all_system_info, get_memory_info
+from benchmarks.cpu_bench import run_all_cpu_benchmarks
+from benchmarks.memory_bench import run_all_memory_benchmarks
+from benchmarks.disk_bench import run_all_disk_benchmarks
+from benchmarks.gpu_bench import run_all_gpu_benchmarks, check_gpu_available
+
+
+# 缓存基准测试结果
+benchmark_cache: Dict[str, Any] = {}
+benchmark_running: Dict[str, bool] = {
+    "cpu": False,
+    "memory": False,
+    "disk": False,
+    "gpu": False,
+    "all": False,
+}
+
+
+class BenchmarkStatus(BaseModel):
+    running: bool
+    results: Optional[Dict[str, Any]] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理"""
+    # 启动时收集系统信息
+    benchmark_cache["system_info"] = get_all_system_info()
+    yield
+    # 关闭时清理
+    benchmark_cache.clear()
+
+
+app = FastAPI(
+    title="Space Fetch",
+    description="System Performance Dashboard for Hugging Face Spaces",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+
+# ==================== API 路由 ====================
+
+@app.get("/api/system", response_class=JSONResponse)
+async def get_system_info():
+    """获取系统信息"""
+    if "system_info" not in benchmark_cache:
+        benchmark_cache["system_info"] = get_all_system_info()
+    return benchmark_cache["system_info"]
+
+
+@app.get("/api/monitor/memory", response_class=JSONResponse)
+async def get_realtime_memory_info():
+    """获取实时内存信息"""
+    return get_memory_info()
+
+
+
+@app.get("/api/benchmark/status", response_class=JSONResponse)
+async def get_benchmark_status():
+    """获取所有基准测试状态"""
+    return {
+        "running": benchmark_running,
+        "cached": {k: k in benchmark_cache for k in ["cpu", "memory", "disk", "gpu"]},
+        "gpu_available": check_gpu_available(),
+    }
+
+
+async def run_cpu_benchmark_async():
+    """异步运行 CPU 基准测试"""
+    benchmark_running["cpu"] = True
+    try:
+        # 在线程池中运行 CPU 密集型任务
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, run_all_cpu_benchmarks)
+        benchmark_cache["cpu"] = result
+    finally:
+        benchmark_running["cpu"] = False
+
+
+@app.post("/api/benchmark/cpu", response_class=JSONResponse)
+async def start_cpu_benchmark(background_tasks: BackgroundTasks):
+    """启动 CPU 基准测试"""
+    if benchmark_running["cpu"]:
+        return {"status": "already_running"}
+    
+    background_tasks.add_task(run_cpu_benchmark_async)
+    return {"status": "started"}
+
+
+@app.get("/api/benchmark/cpu", response_class=JSONResponse)
+async def get_cpu_benchmark():
+    """获取 CPU 基准测试结果"""
+    return BenchmarkStatus(
+        running=benchmark_running["cpu"],
+        results=benchmark_cache.get("cpu")
+    )
+
+
+async def run_memory_benchmark_async():
+    """异步运行内存基准测试"""
+    benchmark_running["memory"] = True
+    try:
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, run_all_memory_benchmarks)
+        benchmark_cache["memory"] = result
+    finally:
+        benchmark_running["memory"] = False
+
+
+@app.post("/api/benchmark/memory", response_class=JSONResponse)
+async def start_memory_benchmark(background_tasks: BackgroundTasks):
+    """启动内存基准测试"""
+    if benchmark_running["memory"]:
+        return {"status": "already_running"}
+    
+    background_tasks.add_task(run_memory_benchmark_async)
+    return {"status": "started"}
+
+
+@app.get("/api/benchmark/memory", response_class=JSONResponse)
+async def get_memory_benchmark():
+    """获取内存基准测试结果"""
+    return BenchmarkStatus(
+        running=benchmark_running["memory"],
+        results=benchmark_cache.get("memory")
+    )
+
+
+async def run_disk_benchmark_async():
+    """异步运行磁盘基准测试"""
+    benchmark_running["disk"] = True
+    try:
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, run_all_disk_benchmarks)
+        benchmark_cache["disk"] = result
+    finally:
+        benchmark_running["disk"] = False
+
+
+@app.post("/api/benchmark/disk", response_class=JSONResponse)
+async def start_disk_benchmark(background_tasks: BackgroundTasks):
+    """启动磁盘基准测试"""
+    if benchmark_running["disk"]:
+        return {"status": "already_running"}
+    
+    background_tasks.add_task(run_disk_benchmark_async)
+    return {"status": "started"}
+
+
+@app.get("/api/benchmark/disk", response_class=JSONResponse)
+async def get_disk_benchmark():
+    """获取磁��基准测试结果"""
+    return BenchmarkStatus(
+        running=benchmark_running["disk"],
+        results=benchmark_cache.get("disk")
+    )
+
+
+async def run_gpu_benchmark_async():
+    """异步运行 GPU 基准测试"""
+    benchmark_running["gpu"] = True
+    try:
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, run_all_gpu_benchmarks)
+        benchmark_cache["gpu"] = result
+    finally:
+        benchmark_running["gpu"] = False
+
+
+@app.post("/api/benchmark/gpu", response_class=JSONResponse)
+async def start_gpu_benchmark(background_tasks: BackgroundTasks):
+    """启动 GPU 基准测试"""
+    if not check_gpu_available():
+        return {"status": "no_gpu", "error": "No NVIDIA GPU detected"}
+    
+    if benchmark_running["gpu"]:
+        return {"status": "already_running"}
+    
+    background_tasks.add_task(run_gpu_benchmark_async)
+    return {"status": "started"}
+
+
+@app.get("/api/benchmark/gpu", response_class=JSONResponse)
+async def get_gpu_benchmark():
+    """获取 GPU 基准测试结果"""
+    return BenchmarkStatus(
+        running=benchmark_running["gpu"],
+        results=benchmark_cache.get("gpu")
+    )
+
+
+async def run_all_benchmarks_async():
+    """异步运行所有基准测试"""
+    benchmark_running["all"] = True
+    try:
+        loop = asyncio.get_event_loop()
+        
+        # CPU
+        benchmark_running["cpu"] = True
+        benchmark_cache["cpu"] = await loop.run_in_executor(None, run_all_cpu_benchmarks)
+        benchmark_running["cpu"] = False
+        
+        # Memory
+        benchmark_running["memory"] = True
+        benchmark_cache["memory"] = await loop.run_in_executor(None, run_all_memory_benchmarks)
+        benchmark_running["memory"] = False
+        
+        # Disk
+        benchmark_running["disk"] = True
+        benchmark_cache["disk"] = await loop.run_in_executor(None, run_all_disk_benchmarks)
+        benchmark_running["disk"] = False
+        
+        # GPU (if available)
+        if check_gpu_available():
+            benchmark_running["gpu"] = True
+            benchmark_cache["gpu"] = await loop.run_in_executor(None, run_all_gpu_benchmarks)
+            benchmark_running["gpu"] = False
+        
+    finally:
+        benchmark_running["all"] = False
+
+
+@app.post("/api/benchmark/all", response_class=JSONResponse)
+async def start_all_benchmarks(background_tasks: BackgroundTasks):
+    """启动所有基准测试"""
+    if benchmark_running["all"]:
+        return {"status": "already_running"}
+    
+    background_tasks.add_task(run_all_benchmarks_async)
+    return {"status": "started"}
+
+
+@app.get("/api/benchmark/all", response_class=JSONResponse)
+async def get_all_benchmarks():
+    """获取所有基准测试结果"""
+    return {
+        "running": benchmark_running["all"],
+        "cpu": benchmark_cache.get("cpu"),
+        "memory": benchmark_cache.get("memory"),
+        "disk": benchmark_cache.get("disk"),
+        "gpu": benchmark_cache.get("gpu"),
+    }
+
+
+@app.get("/api/export", response_class=JSONResponse)
+async def export_results():
+    """导出所有结果为 JSON"""
+    return {
+        "system_info": benchmark_cache.get("system_info"),
+        "benchmarks": {
+            "cpu": benchmark_cache.get("cpu"),
+            "memory": benchmark_cache.get("memory"),
+            "disk": benchmark_cache.get("disk"),
+            "gpu": benchmark_cache.get("gpu"),
+        }
+    }
+
+
+# ==================== 静态文件服务 ====================
+
+# 挂载静态文件目录
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """返回主页"""
+    with open("static/index.html", "r", encoding="utf-8") as f:
+        return HTMLResponse(content=f.read())
+
+
+# ==================== 启动 ====================
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,
+        reload=False,
+        workers=1,
+    )

benchmarks/__init__.py

@@ -0,0 +1 @@
+# Benchmark modules

benchmarks/cpu_bench.py

@@ -0,0 +1,361 @@
+"""
+CPU Benchmark Module
+Optimized with native C library compilation for maximum performance
+"""
+
+import time
+import os
+import ctypes
+import hashlib
+import multiprocessing
+import subprocess
+import zlib
+from concurrent.futures import ProcessPoolExecutor
+from typing import Dict, Any, Optional
+
+# Path to the C source and compiled library
+CPU_OPS_SRC = os.path.join(os.path.dirname(__file__), "cpu_ops.c")
+CPU_OPS_LIB = os.path.join(os.path.dirname(__file__), "cpu_ops.so")
+
+# Global reference to the Loaded Library
+_lib = None
+
+def compile_and_load_lib() -> Optional[ctypes.CDLL]:
+    """Compile and load the C library"""
+    global _lib
+    if _lib is not None:
+        return _lib
+        
+    try:
+        # 1. Try to load existing library first (Avoid race condition in workers)
+        if os.path.exists(CPU_OPS_LIB):
+            try:
+                lib = ctypes.CDLL(CPU_OPS_LIB)
+                _init_lib_signatures(lib)
+                _lib = lib
+                return lib
+            except OSError:
+                # File might be corrupted or empty, proceed to compile
+                pass
+
+        # 2. Check if source exists
+        if not os.path.exists(CPU_OPS_SRC):
+            print(f"Error: {CPU_OPS_SRC} not found")
+            return None
+            
+        # 3. Compile (Only if loading failed or didn't exist)
+        # gcc -shared -o cpu_ops.so -fPIC -O3 cpu_ops.c -lm
+        cmd = [
+            "gcc", "-shared", "-o", CPU_OPS_LIB, 
+            "-fPIC", "-O3", CPU_OPS_SRC, "-lm"
+        ]
+        
+        # Run compilation
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print(f"Compilation failed: {result.stderr}")
+            return None
+            
+        # 4. Load library
+        lib = ctypes.CDLL(CPU_OPS_LIB)
+        _init_lib_signatures(lib)
+        
+        _lib = lib
+        return lib
+    except Exception as e:
+        print(f"Failed to load native lib: {e}")
+        try:
+            # Try to cleanup bad file if it exists
+            if os.path.exists(CPU_OPS_LIB):
+                os.remove(CPU_OPS_LIB)
+        except:
+            pass
+        return None
+
+def _init_lib_signatures(lib):
+    """Initialize function signatures"""
+    try:
+        lib.benchmark_integer_time.argtypes = [ctypes.c_double]
+        lib.benchmark_integer_time.restype = ctypes.c_uint64
+        
+        lib.benchmark_float_time.argtypes = [ctypes.c_double]
+        lib.benchmark_float_time.restype = ctypes.c_uint64
+    except AttributeError:
+        pass
+
+def _native_worker_integer(duration: float) -> int:
+    """Worker for integer benchmark using native C"""
+    lib = compile_and_load_lib()
+    if lib:
+        return lib.benchmark_integer_time(duration)
+    return 0
+
+def _native_worker_float(duration: float) -> int:
+    """Worker for float benchmark using native C"""
+    lib = compile_and_load_lib()
+    if lib:
+        return lib.benchmark_float_time(duration)
+    return 0
+
+# ---------------------------------------------------------------------------
+# Python Fallbacks (Legacy)
+# ---------------------------------------------------------------------------
+def _is_prime(n: int) -> bool:
+    if n < 2: return False
+    if n == 2: return True
+    if n % 2 == 0: return False
+    for i in range(3, int(n**0.5) + 1, 2):
+        if n % i == 0: return False
+    return True
+
+def _python_single_core_integer(duration: float) -> int:
+    start = time.time()
+    n = 3
+    ops = 0
+    while time.time() - start < duration:
+        if _is_prime(n): pass
+        n += 1
+        ops += 1
+    return ops
+
+# ---------------------------------------------------------------------------
+# Benchmarks
+# ---------------------------------------------------------------------------
+
+def benchmark_single_core_integer(duration: float = 2.0) -> Dict[str, Any]:
+    """单核整数运算测试 (Native C)"""
+    # 尝试加载 C 库
+    lib = compile_and_load_lib()
+    
+    if lib:
+        # Native Run
+        start_time = time.time()
+        operations = lib.benchmark_integer_time(duration)
+        elapsed = time.time() - start_time # Should be close to duration
+        
+        # Fix elapsed if it differs significantly (C function returns strictly after duration)
+        if elapsed < duration: elapsed = duration
+        
+        desc = "Prime calculation (Native C)"
+    else:
+        # Fallback
+        start_time = time.time()
+        operations = _python_single_core_integer(duration)
+        elapsed = time.time() - start_time
+        desc = "Prime calculation (Python Fallback)"
+    
+    ops_per_sec = operations / elapsed if elapsed > 0 else 0
+    
+    return {
+        "test": "single_core_integer",
+        "description": desc,
+        "duration_seconds": round(elapsed, 3),
+        "operations": operations,
+        "ops_per_second": round(ops_per_sec, 2),
+        "score": round(ops_per_sec / 100000, 2), # Adjusted score scaling for C speed
+    }
+
+
+def benchmark_multi_core_integer(duration: float = 2.0) -> Dict[str, Any]:
+    """多核整数运算测试 (Native C, Parallel)"""
+    num_cores = multiprocessing.cpu_count()
+    
+    # Check if native available
+    lib = compile_and_load_lib()
+    use_native = (lib is not None)
+    
+    start_time = time.time()
+    
+    with ProcessPoolExecutor(max_workers=num_cores) as executor:
+        if use_native:
+            futures = [executor.submit(_native_worker_integer, duration) for _ in range(num_cores)]
+        else:
+            # Simple python fallback wrapper
+            futures = [executor.submit(_python_single_core_integer, duration) for _ in range(num_cores)]
+            
+        total_ops = sum(f.result() for f in futures)
+    
+    elapsed = time.time() - start_time
+    # Parallel execution usually takes slightly longer than 'duration' due to overhead
+    if elapsed < duration: elapsed = duration
+        
+    ops_per_sec = total_ops / elapsed
+    
+    # Efficiency
+    single_core_perf = ops_per_sec / num_cores # Average per core
+    # We can't easily calc efficiency without a distinct single core run, but we can assume ideal
+    
+    desc = f"Parallel Prime Calc ({num_cores} cores, {'Native C' if use_native else 'Python'})"
+    
+    return {
+        "test": "multi_core_integer",
+        "description": desc,
+        "duration_seconds": round(elapsed, 3),
+        "cores_used": num_cores,
+        "operations": total_ops,
+        "ops_per_second": round(ops_per_sec, 2),
+        "score": round(ops_per_sec / 100000, 2),
+    }
+
+
+def benchmark_single_core_float(duration: float = 2.0) -> Dict[str, Any]:
+    """单核浮点运算测试 (Native C Math)"""
+    lib = compile_and_load_lib()
+    
+    if lib:
+        start_time = time.time()
+        operations = lib.benchmark_float_time(duration)
+        elapsed = time.time() - start_time
+        desc = "Heavy Math (Native C: sin/cos/sqrt)"
+    else:
+        # Fallback to simple python
+        start_time = time.time()
+        # Very simple python float loop
+        a = 1.1
+        ops = 0
+        while time.time() - start_time < duration:
+            for _ in range(1000):
+                a = (a * 1.000001) + 0.000001
+                ops += 1
+        elapsed = time.time() - start_time
+        operations = ops
+        desc = "Float Loop (Python Fallback)"
+        
+    ops_per_sec = operations / elapsed if elapsed > 0 else 0
+    
+    # Estimate FLOPs
+    # Native C: sin/cos/sqrt mix -> approx 20 FLOPs per iteration
+    # Python: simple mul/add -> approx 2 FLOPs per iteration
+    flops_per_op = 20 if lib else 2
+    gflops = (ops_per_sec * flops_per_op) / 1e9
+    
+    return {
+        "test": "single_core_float",
+        "description": desc,
+        "duration_seconds": round(elapsed, 3),
+        "operations": operations,
+        "ops_per_second": round(ops_per_sec, 2),
+        "gflops": round(gflops, 4),
+        "score": round(ops_per_sec / 100000, 2),
+    }
+
+
+def benchmark_multi_core_float(duration: float = 2.0) -> Dict[str, Any]:
+    """多核浮点运算测试 (Native C Math)"""
+    num_cores = multiprocessing.cpu_count()
+    lib = compile_and_load_lib()
+    use_native = (lib is not None)
+    
+    start_time = time.time()
+    
+    with ProcessPoolExecutor(max_workers=num_cores) as executor:
+        if use_native:
+            futures = [executor.submit(_native_worker_float, duration) for _ in range(num_cores)]
+        else:
+            # Just return 0 for python fallback multithread float to avoid freezing
+            return {"error": "Native lib required for multi-core float bench"}
+            
+        total_ops = sum(f.result() for f in futures)
+        
+    elapsed = time.time() - start_time
+    ops_per_sec = total_ops / elapsed if elapsed > 0 else 0
+    
+    # Estimate FLOPs (Native C required)
+    flops_per_op = 20
+    gflops = (ops_per_sec * flops_per_op) / 1e9
+    
+    return {
+        "test": "multi_core_float",
+        "description": f"Parallel Math ({num_cores} cores, Native C)",
+        "duration_seconds": round(elapsed, 3),
+        "cores_available": num_cores,
+        "operations": total_ops,
+        "ops_per_second": round(ops_per_sec, 2),
+        "gflops": round(gflops, 4),
+        "score": round(ops_per_sec / 100000, 2),
+    }
+
+
+def benchmark_crypto(duration: float = 2.0) -> Dict[str, Any]:
+    """加密性能测试 (OpenSSL via hashlib)"""
+    # hashlib calls C-level OpenSSL, so it is already valid "native" benchmark
+    data = b'x' * 1024 * 1024  # 1MB
+    start_time = time.time()
+    iterations = 0
+    
+    while time.time() - start_time < duration:
+        hashlib.sha256(data).hexdigest()
+        iterations += 1
+    
+    elapsed = time.time() - start_time
+    mb_per_sec = iterations / elapsed
+    
+    return {
+        "test": "crypto_sha256",
+        "description": "SHA256 Hashing (OpenSSL)",
+        "duration_seconds": round(elapsed, 3),
+        "throughput_mb_per_sec": round(mb_per_sec, 2),
+        "score": round(mb_per_sec * 2, 2),
+    }
+
+def benchmark_compression(duration: float = 2.0) -> Dict[str, Any]:
+    """压缩性能测试 (zlib C library)"""
+    # zlib calls C-level library
+    chunk_size = 1024 * 1024
+    data = os.urandom(chunk_size)
+    start_time = time.time()
+    total_bytes = 0
+    
+    while time.time() - start_time < duration:
+        c = zlib.compress(data, level=6)
+        _ = zlib.decompress(c)
+        total_bytes += chunk_size
+        
+    elapsed = time.time() - start_time
+    mb_per_sec = (total_bytes / elapsed) / (1024 * 1024)
+    
+    return {
+        "test": "compression_zlib",
+        "description": "Zlib Compression (Native)",
+        "duration_seconds": round(elapsed, 3),
+        "throughput_mb_per_sec": round(mb_per_sec, 2),
+        "score": round(mb_per_sec * 0.5, 2),
+    }
+
+def benchmark_single_thread_stress(duration: float = 2.0) -> Dict[str, Any]:
+    """单线程调度延迟 (System Call Stress)"""
+    # time.sleep calls nanosleep syscall, which is a good test for kernel scheduler
+    start_time = time.time()
+    iterations = 0
+    while time.time() - start_time < duration:
+        time.sleep(0.0001)
+        iterations += 1
+    elapsed = time.time() - start_time
+    
+    return {
+        "test": "single_thread_stress",
+        "description": "Scheduler Stress (nanosleep syscall)",
+        "duration_seconds": round(elapsed, 3),
+        "wakeups_per_second": round(iterations / elapsed, 2),
+        "score": round(iterations / elapsed / 100, 2),
+    }
+
+def run_all_cpu_benchmarks() -> Dict[str, Any]:
+    # Ensure lib is compiled once at start
+    compile_and_load_lib()
+    
+    results = {
+        "single_core_integer": benchmark_single_core_integer(),
+        "multi_core_integer": benchmark_multi_core_integer(),
+        "single_core_float": benchmark_single_core_float(),
+        "multi_core_float": benchmark_multi_core_float(),
+        "crypto": benchmark_crypto(),
+        "compression": benchmark_compression(),
+        "stress": benchmark_single_thread_stress(),
+    }
+    
+    # Recalculate total score
+    total_score = sum(r.get("score", 0) for r in results.values() if "score" in r)
+    results["total_score"] = round(total_score, 2)
+    
+    return results

benchmarks/cpu_ops.c

@@ -0,0 +1,105 @@
+#include <math.h>
+#include <time.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+// --------------------------------------------------------------------------
+// Integer Benchmark: Prime Number Calculation
+// --------------------------------------------------------------------------
+
+// Simple unoptimized prime check for stress testing
+int is_prime(uint64_t n) {
+    if (n < 2) return 0;
+    if (n == 2) return 1;
+    if (n % 2 == 0) return 0;
+    
+    // Using sqrt loop
+    uint64_t limit = (uint64_t)sqrt(n);
+    for (uint64_t i = 3; i <= limit; i += 2) {
+        if (n % i == 0) return 0;
+    }
+    return 1;
+}
+
+// Check primes in a range. Returns number of primes found.
+// Used for parallel execution validation, but for pure stress we can just run for time.
+uint64_t count_primes_in_range(uint64_t start, uint64_t end) {
+    uint64_t count = 0;
+    for (uint64_t n = start; n < end; n++) {
+        if (is_prime(n)) {
+            count++;
+        }
+    }
+    return count;
+}
+
+// Run prime calculation for exactly `duration` seconds
+// Returns total numbers checked
+uint64_t benchmark_integer_time(double duration) {
+    struct timespec start_ts, current_ts;
+    clock_gettime(CLOCK_MONOTONIC, &start_ts);
+    
+    uint64_t n = 3; // Start from 3
+    uint64_t ops = 0;
+    
+    while (1) {
+        // Bulk check to reduce clock_gettime overhead
+        for (int i = 0; i < 1000; i++) {
+            is_prime(n++);
+            ops++;
+        }
+        
+        clock_gettime(CLOCK_MONOTONIC, &current_ts);
+        double elapsed = (current_ts.tv_sec - start_ts.tv_sec) + 
+                         (current_ts.tv_nsec - start_ts.tv_nsec) * 1e-9;
+        
+        if (elapsed >= duration) {
+            break;
+        }
+    }
+    return ops;
+}
+
+// --------------------------------------------------------------------------
+// Single Core Stress: Context Switch Simulation (Busy Wait vs Sleep)
+// --------------------------------------------------------------------------
+// Actually, pure C sleep logic might be better than Python's sleep(0.0001) overhead.
+// But context switching involves system calls.
+// Let's implement a busy-loop or heavy computation stub.
+
+// --------------------------------------------------------------------------
+// Float Benchmark: Heavy Math
+// --------------------------------------------------------------------------
+
+// Perform heavy floating point ops: sin, cos, sqrt
+uint64_t benchmark_float_time(double duration) {
+    struct timespec start_ts, current_ts;
+    clock_gettime(CLOCK_MONOTONIC, &start_ts);
+    
+    double a = 1.1;
+    double b = 2.2;
+    double c = 3.3;
+    uint64_t ops = 0;
+    
+    while (1) {
+        for (int i = 0; i < 1000; i++) {
+            a = sin(a) * cos(b) + sqrt(fabs(c));
+            b = cos(a) * sin(c) + sqrt(fabs(b));
+            c = a + b;
+            // Keep them bounded to avoid inf/nan issues affecting perf slightly
+            if (a > 1000.0) a = 1.1;
+            if (b > 1000.0) b = 2.2;
+            if (c > 1000.0) c = 3.3;
+            ops++;
+        }
+        
+        clock_gettime(CLOCK_MONOTONIC, &current_ts);
+        double elapsed = (current_ts.tv_sec - start_ts.tv_sec) + 
+                         (current_ts.tv_nsec - start_ts.tv_nsec) * 1e-9;
+        
+        if (elapsed >= duration) {
+            break;
+        }
+    }
+    return ops;
+}

benchmarks/disk_bench.py

@@ -0,0 +1,178 @@
+"""
+Disk Benchmark Module
+磁盘 I/O 性能测试：顺序读写、随机 IOPS
+"""
+
+import os
+import time
+import tempfile
+import numpy as np
+from typing import Dict, Any
+
+
+def benchmark_sequential_write(size_mb: int = 256, block_size_kb: int = 1024) -> Dict[str, Any]:
+    """顺序写入测试"""
+    block_size = block_size_kb * 1024
+    total_size = size_mb * 1024 * 1024
+    num_blocks = total_size // block_size
+    
+    # 创建随机数据块
+    data = os.urandom(block_size)
+    
+    # 创建临时文件
+    with tempfile.NamedTemporaryFile(delete=True) as f:
+        start_time = time.time()
+        
+        for _ in range(num_blocks):
+            f.write(data)
+        f.flush()
+        os.fsync(f.fileno())
+        
+        elapsed = time.time() - start_time
+    
+    throughput = size_mb / elapsed
+    
+    return {
+        "test": "sequential_write",
+        "description": f"Sequential write ({size_mb}MB, {block_size_kb}KB blocks)",
+        "size_mb": size_mb,
+        "block_size_kb": block_size_kb,
+        "duration_seconds": round(elapsed, 3),
+        "throughput_mb_s": round(throughput, 2),
+        "score": round(throughput / 10, 2),
+    }
+
+
+def benchmark_sequential_read(size_mb: int = 256, block_size_kb: int = 1024) -> Dict[str, Any]:
+    """顺序读取测试"""
+    block_size = block_size_kb * 1024
+    total_size = size_mb * 1024 * 1024
+    
+    # 创建临时文件并写入数据
+    with tempfile.NamedTemporaryFile(delete=True) as f:
+        # 先写入数据
+        data = os.urandom(block_size)
+        num_blocks = total_size // block_size
+        for _ in range(num_blocks):
+            f.write(data)
+        f.flush()
+        os.fsync(f.fileno())
+        
+        # 清除缓存（尝试）
+        try:
+            os.system('sync; echo 3 > /proc/sys/vm/drop_caches 2>/dev/null')
+        except:
+            pass
+        
+        # 顺序读取
+        f.seek(0)
+        start_time = time.time()
+        
+        while f.read(block_size):
+            pass
+        
+        elapsed = time.time() - start_time
+    
+    throughput = size_mb / elapsed
+    
+    return {
+        "test": "sequential_read",
+        "description": f"Sequential read ({size_mb}MB, {block_size_kb}KB blocks)",
+        "size_mb": size_mb,
+        "block_size_kb": block_size_kb,
+        "duration_seconds": round(elapsed, 3),
+        "throughput_mb_s": round(throughput, 2),
+        "score": round(throughput / 10, 2),
+    }
+
+
+def benchmark_random_read_iops(duration: float = 3.0, block_size: int = 4096) -> Dict[str, Any]:
+    """随机读取 IOPS 测试"""
+    file_size = 128 * 1024 * 1024  # 128MB 文件
+    
+    with tempfile.NamedTemporaryFile(delete=True) as f:
+        # 创建文件
+        f.write(os.urandom(file_size))
+        f.flush()
+        os.fsync(f.fileno())
+        
+        # 计算可用的偏移量
+        max_offset = file_size - block_size
+        
+        # 随机读取测试
+        start_time = time.time()
+        operations = 0
+        
+        while time.time() - start_time < duration:
+            offset = np.random.randint(0, max_offset)
+            f.seek(offset)
+            f.read(block_size)
+            operations += 1
+        
+        elapsed = time.time() - start_time
+    
+    iops = operations / elapsed
+    
+    return {
+        "test": "random_read_iops",
+        "description": f"Random 4K read IOPS",
+        "block_size_bytes": block_size,
+        "duration_seconds": round(elapsed, 3),
+        "operations": operations,
+        "iops": round(iops, 2),
+        "score": round(iops / 100, 2),
+    }
+
+
+def benchmark_random_write_iops(duration: float = 3.0, block_size: int = 4096) -> Dict[str, Any]:
+    """随机写入 IOPS 测试"""
+    file_size = 128 * 1024 * 1024  # 128MB 文件
+    data = os.urandom(block_size)
+    
+    with tempfile.NamedTemporaryFile(delete=True) as f:
+        # 预分配文件空间
+        f.write(os.urandom(file_size))
+        f.flush()
+        
+        max_offset = file_size - block_size
+        
+        # 随机写入测试
+        start_time = time.time()
+        operations = 0
+        
+        while time.time() - start_time < duration:
+            offset = np.random.randint(0, max_offset)
+            f.seek(offset)
+            f.write(data)
+            operations += 1
+        
+        f.flush()
+        elapsed = time.time() - start_time
+    
+    iops = operations / elapsed
+    
+    return {
+        "test": "random_write_iops",
+        "description": f"Random 4K write IOPS",
+        "block_size_bytes": block_size,
+        "duration_seconds": round(elapsed, 3),
+        "operations": operations,
+        "iops": round(iops, 2),
+        "score": round(iops / 100, 2),
+    }
+
+
+def run_all_disk_benchmarks() -> Dict[str, Any]:
+    """运行所有磁盘基准测试"""
+    results = {
+        "sequential_write": benchmark_sequential_write(),
+        "sequential_read": benchmark_sequential_read(),
+        "random_read_iops": benchmark_random_read_iops(),
+        "random_write_iops": benchmark_random_write_iops(),
+    }
+    
+    # 计算总分
+    total_score = sum(r.get("score", 0) for r in results.values())
+    results["total_score"] = round(total_score, 2)
+    
+    return results

benchmarks/gpu_bench.py

@@ -0,0 +1,255 @@
+"""
+GPU Benchmark Module
+GPU 性能测试：显存带宽、FP32/FP16/Tensor Core 算力
+仅在有 NVIDIA GPU 时可用
+"""
+
+import time
+from typing import Dict, Any, Optional
+
+
+def check_gpu_available() -> bool:
+    """检查是否有可用的 GPU"""
+    try:
+        import subprocess
+        result = subprocess.run(['nvidia-smi'], capture_output=True, timeout=5)
+        return result.returncode == 0
+    except:
+        return False
+
+
+def check_cuda_available() -> bool:
+    """检查 PyTorch CUDA 是否可用"""
+    try:
+        import torch
+        return torch.cuda.is_available()
+    except ImportError:
+        return False
+
+
+def benchmark_gpu_memory_bandwidth() -> Optional[Dict[str, Any]]:
+    """GPU 显存带宽测试"""
+    if not check_cuda_available():
+        return None
+    
+    try:
+        import torch
+        
+        device = torch.device('cuda')
+        
+        # 测试不同大小
+        size_mb = 256
+        size_elements = size_mb * 1024 * 1024 // 4  # float32
+        
+        # 创建张量
+        src = torch.ones(size_elements, dtype=torch.float32, device=device)
+        
+        # 预热
+        for _ in range(10):
+            dst = src.clone()
+        torch.cuda.synchronize()
+        
+        # 带宽测试
+        start_time = time.time()
+        iterations = 0
+        while time.time() - start_time < 2.0:
+            dst = src.clone()
+            iterations += 1
+        torch.cuda.synchronize()
+        elapsed = time.time() - start_time
+        
+        # 计算带宽 (读 + 写)
+        bytes_transferred = size_mb * 1024 * 1024 * 2 * iterations
+        bandwidth = bytes_transferred / elapsed / (1024**3)
+        
+        return {
+            "test": "gpu_memory_bandwidth",
+            "description": f"GPU memory bandwidth ({size_mb}MB)",
+            "size_mb": size_mb,
+            "duration_seconds": round(elapsed, 3),
+            "iterations": iterations,
+            "bandwidth_gb_s": round(bandwidth, 2),
+            "score": round(bandwidth, 2),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def benchmark_gpu_fp32(matrix_size: int = 4096) -> Optional[Dict[str, Any]]:
+    """GPU FP32 算力测试"""
+    if not check_cuda_available():
+        return None
+    
+    try:
+        import torch
+        
+        device = torch.device('cuda')
+        
+        # 创建矩阵
+        a = torch.randn(matrix_size, matrix_size, dtype=torch.float32, device=device)
+        b = torch.randn(matrix_size, matrix_size, dtype=torch.float32, device=device)
+        
+        # 预热
+        for _ in range(5):
+            _ = torch.mm(a, b)
+        torch.cuda.synchronize()
+        
+        # 测试
+        start_time = time.time()
+        iterations = 0
+        while time.time() - start_time < 3.0:
+            _ = torch.mm(a, b)
+            iterations += 1
+        torch.cuda.synchronize()
+        elapsed = time.time() - start_time
+        
+        # 计算 TFLOPS
+        flops_per_matmul = 2 * (matrix_size ** 3)
+        total_flops = flops_per_matmul * iterations
+        tflops = total_flops / elapsed / 1e12
+        
+        return {
+            "test": "gpu_fp32",
+            "description": f"GPU FP32 compute ({matrix_size}x{matrix_size} matmul)",
+            "matrix_size": matrix_size,
+            "duration_seconds": round(elapsed, 3),
+            "iterations": iterations,
+            "tflops": round(tflops, 3),
+            "score": round(tflops * 10, 2),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def benchmark_gpu_fp16(matrix_size: int = 4096) -> Optional[Dict[str, Any]]:
+    """GPU FP16 算力测试"""
+    if not check_cuda_available():
+        return None
+    
+    try:
+        import torch
+        
+        device = torch.device('cuda')
+        
+        # 创建矩阵
+        a = torch.randn(matrix_size, matrix_size, dtype=torch.float16, device=device)
+        b = torch.randn(matrix_size, matrix_size, dtype=torch.float16, device=device)
+        
+        # 预热
+        for _ in range(5):
+            _ = torch.mm(a, b)
+        torch.cuda.synchronize()
+        
+        # 测试
+        start_time = time.time()
+        iterations = 0
+        while time.time() - start_time < 3.0:
+            _ = torch.mm(a, b)
+            iterations += 1
+        torch.cuda.synchronize()
+        elapsed = time.time() - start_time
+        
+        # 计算 TFLOPS
+        flops_per_matmul = 2 * (matrix_size ** 3)
+        total_flops = flops_per_matmul * iterations
+        tflops = total_flops / elapsed / 1e12
+        
+        return {
+            "test": "gpu_fp16",
+            "description": f"GPU FP16 compute ({matrix_size}x{matrix_size} matmul)",
+            "matrix_size": matrix_size,
+            "duration_seconds": round(elapsed, 3),
+            "iterations": iterations,
+            "tflops": round(tflops, 3),
+            "score": round(tflops * 5, 2),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def benchmark_gpu_tensor_cores(matrix_size: int = 4096) -> Optional[Dict[str, Any]]:
+    """GPU Tensor Core 混合精度算力测试"""
+    if not check_cuda_available():
+        return None
+    
+    try:
+        import torch
+        
+        if not hasattr(torch.cuda, 'amp') or torch.cuda.get_device_capability()[0] < 7:
+            return {"error": "Tensor Cores not available (requires compute capability >= 7.0)"}
+        
+        device = torch.device('cuda')
+        
+        # 使用自动混合精度
+        a = torch.randn(matrix_size, matrix_size, dtype=torch.float16, device=device)
+        b = torch.randn(matrix_size, matrix_size, dtype=torch.float16, device=device)
+        
+        # 预热
+        with torch.cuda.amp.autocast():
+            for _ in range(5):
+                _ = torch.mm(a, b)
+        torch.cuda.synchronize()
+        
+        # 测试
+        start_time = time.time()
+        iterations = 0
+        with torch.cuda.amp.autocast():
+            while time.time() - start_time < 3.0:
+                _ = torch.mm(a, b)
+                iterations += 1
+        torch.cuda.synchronize()
+        elapsed = time.time() - start_time
+        
+        # 计算 TFLOPS
+        flops_per_matmul = 2 * (matrix_size ** 3)
+        total_flops = flops_per_matmul * iterations
+        tflops = total_flops / elapsed / 1e12
+        
+        return {
+            "test": "gpu_tensor_cores",
+            "description": f"GPU Tensor Cores mixed precision ({matrix_size}x{matrix_size})",
+            "matrix_size": matrix_size,
+            "duration_seconds": round(elapsed, 3),
+            "iterations": iterations,
+            "tflops": round(tflops, 3),
+            "score": round(tflops * 3, 2),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def run_all_gpu_benchmarks() -> Optional[Dict[str, Any]]:
+    """运行所有 GPU 基准测试"""
+    if not check_gpu_available():
+        return None
+    
+    results = {}
+    
+    # 内存带宽
+    mem_result = benchmark_gpu_memory_bandwidth()
+    if mem_result:
+        results["memory_bandwidth"] = mem_result
+    
+    # FP32 算力
+    fp32_result = benchmark_gpu_fp32()
+    if fp32_result:
+        results["fp32"] = fp32_result
+    
+    # FP16 算力
+    fp16_result = benchmark_gpu_fp16()
+    if fp16_result:
+        results["fp16"] = fp16_result
+    
+    # Tensor Cores
+    tc_result = benchmark_gpu_tensor_cores()
+    if tc_result:
+        results["tensor_cores"] = tc_result
+    
+    if not results:
+        return None
+    
+    # 计算总分
+    total_score = sum(r.get("score", 0) for r in results.values() if isinstance(r, dict) and "error" not in r)
+    results["total_score"] = round(total_score, 2)
+    
+    return results

benchmarks/memory_bench.py

@@ -0,0 +1,331 @@
+"""
+Memory Benchmark Module
+内存性能测试：带宽测试、延迟测试、缓存性能
+Optimized with ctypes for raw C-level performance
+"""
+
+import time
+import ctypes
+import multiprocessing
+import mmap
+import os
+import numpy as np  # Keep for latency/cache tests
+from concurrent.futures import ProcessPoolExecutor
+from typing import Dict, Any
+
+# Load C standard library
+try:
+    libc = ctypes.CDLL("libc.so.6")
+    libc.memset.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_size_t]
+    libc.memcpy.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
+    libc.memchr.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_size_t]
+except Exception:
+    libc = None
+
+# --- C Extension Handling ---
+C_LIB_PATH = os.path.join(os.path.dirname(__file__), "_memory_bench_c.so")
+C_SRC_PATH = os.path.join(os.path.dirname(__file__), "memory_bench_c.c")
+
+def _compile_c_helper():
+    """Compiles the C helper library if it doesn't exist or is outdated."""
+    if not os.path.exists(C_SRC_PATH):
+        return None
+        
+    needs_compile = False
+    if not os.path.exists(C_LIB_PATH):
+        needs_compile = True
+    else:
+        # Check timestamps
+        if os.path.getmtime(C_SRC_PATH) > os.path.getmtime(C_LIB_PATH):
+            needs_compile = True
+            
+    if needs_compile:
+        # User requested max optimization
+        cmd = f"gcc -O3 -shared -fPIC -o {C_LIB_PATH} {C_SRC_PATH}"
+        if os.system(cmd) != 0:
+            print("Failed to compile C helper.")
+            return None
+            
+    try:
+        lib = ctypes.CDLL(C_LIB_PATH)
+        lib.measure_latency_random.argtypes = [ctypes.c_size_t, ctypes.c_size_t]
+        lib.measure_latency_random.restype = ctypes.c_double
+        
+        lib.measure_latency_sequential.argtypes = [ctypes.c_size_t, ctypes.c_size_t]
+        lib.measure_latency_sequential.restype = ctypes.c_double
+        
+        lib.measure_alloc_rate.argtypes = [ctypes.c_size_t, ctypes.c_size_t]
+        lib.measure_alloc_rate.restype = ctypes.c_double
+        return lib
+    except Exception as e:
+        print(f"Failed to load C helper: {e}")
+        return None
+
+c_lib = _compile_c_helper()
+
+def _raw_memory_worker(args):
+    """
+    Worker process for memory bandwidth test using raw C calls.
+    Equivalent to sysbench memory test.
+    """
+    block_size_mb, duration, mode = args
+    block_size = block_size_mb * 1024 * 1024
+    
+    # Use mmap for aligned, raw memory allocation (no Python object overhead)
+    # Anonymous mapping
+    src_map = mmap.mmap(-1, block_size)
+    dst_map = None
+    
+    # For copy mode, we need a destination
+    if mode == 'copy':
+        dst_map = mmap.mmap(-1, block_size)
+    
+    # Get raw pointers
+    src_addr = ctypes.addressof(ctypes.c_char.from_buffer(src_map))
+    dst_addr = ctypes.addressof(ctypes.c_char.from_buffer(dst_map)) if dst_map else 0
+    
+    # Prepare C function calls
+    memset = libc.memset
+    memcpy = libc.memcpy
+    memchr = libc.memchr
+    
+    start_time = time.time()
+    iterations = 0
+    
+    while time.time() - start_time < duration:
+        if mode == 'read':
+            # Scan memory (read access)
+            # Find a byte that (likely) isn't there to force full scan
+            memchr(src_addr, 1, block_size)
+        elif mode == 'write':
+            # Write memory
+            memset(src_addr, 0, block_size)
+        elif mode == 'copy':
+            # Copy memory
+            memcpy(dst_addr, src_addr, block_size)
+        iterations += 1
+        
+    elapsed = time.time() - start_time
+    
+    # Cleanup
+    src_map.close()
+    if dst_map:
+        dst_map.close()
+        
+    return iterations, elapsed
+
+def benchmark_memory_bandwidth(block_size_mb: int = 4) -> Dict[str, Any]:
+    """
+    内存带宽测试 (Raw C Performance)
+    Uses multiprocessing + ctypes to bypass Python overhead.
+    """
+    if not libc:
+        return {"error": "libc not found, cannot run optimized benchmark"}
+        
+    num_cores = multiprocessing.cpu_count()
+    duration = 3.0
+    
+    # sysbench defaults to 1KB-1MB blocks. User mentioned 1MB.
+    # We use a slightly larger buffer per thread to amortize loop overhead if needed,
+    # but 1MB-4MB is usually good for L3/RAM cache thrashing.
+    # Let's stick to 4MB per thread to ensure we hit RAM.
+    
+    modes = ['read', 'write', 'copy']
+    results = {}
+    
+    with ProcessPoolExecutor(max_workers=num_cores) as executor:
+        for mode in modes:
+            # Submit tasks
+            futures = [executor.submit(_raw_memory_worker, (block_size_mb, duration, mode)) for _ in range(num_cores)]
+            
+            total_iterations = 0
+            max_elapsed = 0
+            
+            for f in futures:
+                iters, elapsed = f.result()
+                total_iterations += iters
+                max_elapsed = max(max_elapsed, elapsed)
+            
+            # Calculate Bandwidth
+            # Data transferred per iteration = block_size
+            bytes_per_iter = block_size_mb * 1024 * 1024
+            
+            total_bytes = total_iterations * bytes_per_iter
+            
+            # Note: For 'copy', sysbench counts read+write? 
+            # Usually bandwidth is defined as bytes processed.
+            # If we copy 1GB, we read 1GB and write 1GB.
+            # sysbench memory test reports "transferred".
+            # For copy, let's report the amount of data moved (Payload). 
+            # Or if user wants bus bandwidth, it's 2x. 
+            # Benchmarks usually report the size of the buffer processed.
+            # However, previous impl multiplied by 2. Let's stick to total bytes moved over bus.
+            if mode == 'copy':
+                total_bytes *= 2
+            
+            # Avoid division by zero
+            if max_elapsed > 0:
+                bandwidth_gb_s = total_bytes / max_elapsed / (1024**3)
+            else:
+                bandwidth_gb_s = 0
+                
+            results[f"{mode}_bandwidth_gb_s"] = round(bandwidth_gb_s, 3)
+
+    return {
+        "test": "memory_bandwidth",
+        "description": f"Memory bandwidth test (Multi-core C-level, {num_cores} threads)",
+        "block_size_mb": block_size_mb,
+        "read_bandwidth_gb_s": results['read_bandwidth_gb_s'],
+        "write_bandwidth_gb_s": results['write_bandwidth_gb_s'],
+        "copy_bandwidth_gb_s": results['copy_bandwidth_gb_s'],
+        "score": round((results['read_bandwidth_gb_s'] + results['write_bandwidth_gb_s'] + results['copy_bandwidth_gb_s']) * 10, 2),
+    }
+
+
+def benchmark_memory_latency(iterations: int = 10000000) -> Dict[str, Any]:
+    """
+    内存延迟测试（随机访问）
+    Uses C helper for precise pointer chasing.
+    """
+    if not c_lib:
+        return {"error": "C helper not available"}
+        
+    # Test random access latency on a large block (64MB) to hit RAM
+    array_size_bytes = 64 * 1024 * 1024
+    
+    elapsed = c_lib.measure_latency_random(array_size_bytes, iterations)
+    
+    if elapsed <= 0:
+        return {"error": "Benchmark failed"}
+        
+    latency_ns = (elapsed / iterations) * 1e9
+    
+    return {
+        "test": "memory_latency_random",
+        "description": "Random access latency (64MB working set, Pointer Chasing)",
+        "iterations": iterations,
+        "total_time_seconds": round(elapsed, 4),
+        "average_latency_ns": round(latency_ns, 2),
+        "score": round(100 / latency_ns * 1000, 2), # Adjusted score scale
+    }
+
+def benchmark_sequential_latency(iterations: int = 10000000) -> Dict[str, Any]:
+    """
+    内存延迟测试（顺序访问）
+    Uses C helper.
+    """
+    if not c_lib:
+        return {"error": "C helper not available"}
+        
+    # Same 64MB block
+    array_size_bytes = 64 * 1024 * 1024
+    
+    elapsed = c_lib.measure_latency_sequential(array_size_bytes, iterations)
+    
+    if elapsed <= 0:
+        return {"error": "Benchmark failed"}
+        
+    latency_ns = (elapsed / iterations) * 1e9
+    
+    return {
+        "test": "memory_latency_sequential",
+        "description": "Sequential access latency (64MB working set, Strided Read)",
+        "iterations": iterations,
+        "total_time_seconds": round(elapsed, 4),
+        "average_latency_ns": round(latency_ns, 2),
+        "score": round(100 / latency_ns * 1000, 2),
+    }
+
+def benchmark_alloc_rate(iterations: int = 1000000) -> Dict[str, Any]:
+    """
+    内存分配/释放速率测试
+    """
+    if not c_lib:
+        return {"error": "C helper not available"}
+        
+    # Test small allocations (e.g. 1KB) which are common
+    alloc_size = 1024
+    
+    elapsed = c_lib.measure_alloc_rate(alloc_size, iterations)
+    
+    if elapsed <= 0:
+        return {"error": "Benchmark failed"}
+        
+    ops_per_sec = iterations / elapsed
+    
+    return {
+        "test": "memory_alloc_rate",
+        "description": f"Malloc/Free rate (Size: {alloc_size} bytes)",
+        "iterations": iterations,
+        "ops_per_sec": round(ops_per_sec, 2),
+        "score": round(ops_per_sec / 10000, 2),
+    }
+
+
+
+def benchmark_cache_latency() -> Dict[str, Any]:
+    """
+    缓存层级延迟测试 (L1/L2/L3)
+    Uses C helper pointer chasing with smaller working sets.
+    """
+    if not c_lib:
+        return {"error": "C helper not available"}
+        
+    results = {}
+    
+    # Approximate sizes. 
+    # Must be small enough to fit in cache, but large enough to measure.
+    # Typical: L1=32KB(use 16KB), L2=256KB(use 128KB), L3=8MB+(use 4MB)
+    levels = [
+        ("L1", 16 * 1024),
+        ("L2", 128 * 1024),
+        ("L3", 4 * 1024 * 1024)
+    ]
+    
+    iterations = 10000000 # 10M iterations
+    
+    for name, size in levels:
+        elapsed = c_lib.measure_latency_random(size, iterations)
+        latency_ns = (elapsed / iterations) * 1e9
+    for name, size in levels:
+        elapsed = c_lib.measure_latency_random(size, iterations)
+        if elapsed <= 0:
+             # Fallback or error
+             latency_ns = 0.0
+        else:
+             latency_ns = (elapsed / iterations) * 1e9
+             
+        results[name] = {
+            "size_bytes": size,
+            "latency_ns": round(latency_ns, 2)
+        }
+        
+    l1_lat = results["L1"]["latency_ns"]
+    score = 0
+    if l1_lat > 0:
+        score = round(100 / l1_lat * 500, 2)
+        
+    return {
+        "test": "cache_latency",
+        "description": "Cache hierarchy latency (Pointer Chasing)",
+        "levels": results,
+        "score": score
+    }
+
+
+
+def run_all_memory_benchmarks() -> Dict[str, Any]:
+    """运行所有内存基准测试"""
+    results = {
+        "bandwidth": benchmark_memory_bandwidth(),
+        "latency_random": benchmark_memory_latency(),
+        "latency_sequential": benchmark_sequential_latency(),
+        "cache_latency": benchmark_cache_latency(),
+        "alloc_rate": benchmark_alloc_rate(),
+    }
+    
+    # 计算总分
+    total_score = sum(r.get("score", 0) for r in results.values())
+    results["total_score"] = round(total_score, 2)
+    
+    return results

benchmarks/memory_bench_c.c

@@ -0,0 +1,137 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+#include <stdint.h>
+
+// LCG for fast random numbers
+static inline uint32_t fast_rand(uint32_t *seed) {
+    *seed = *seed * 1103515245 + 12345;
+    return (*seed / 65536) % 32768;
+}
+
+// Measure random access latency (Pointer Chasing)
+// size_bytes: Total size of the working set
+// iterations: Number of pointer chases
+double measure_latency_random(size_t size_bytes, size_t iterations) {
+    size_t num_elements = size_bytes / sizeof(void*);
+    if (num_elements < 2) return 0.0;
+
+    void **memory = (void**)malloc(size_bytes);
+    if (!memory) return -1.0;
+
+    // Use a simple Sattolo's algorithm for a single cycle permutation
+    // We want to ensure we visit every element exactly once in a full cycle
+    // But for latency testing, we just need a long chain.
+    // We will do a full shuffle of indices to create the chain.
+    
+    uint32_t *indices = (uint32_t*)malloc(num_elements * sizeof(uint32_t));
+    if (!indices) { free(memory); return -1.0; }
+    
+    for (size_t i = 0; i < num_elements; i++) indices[i] = i;
+
+    uint32_t seed = (uint32_t)time(NULL);
+    // Sattolo's algorithm for cyclic permutation
+    for (size_t i = num_elements - 1; i > 0; i--) {
+        size_t j = fast_rand(&seed) % i; // 0 <= j < i
+        uint32_t temp = indices[i];
+        indices[i] = indices[j];
+        indices[j] = temp;
+    }
+
+    // Link the list
+    // indices[i] -> indices[next] is not quite right for pointer chasing setup easily.
+    // We want memory[i] to point to memory[indices[i]]? No.
+    // We want memory[indices[i]] to point to memory[indices[i+1]].
+    // Actually, Sattolo gives us: value at pos i is the NEXT index.
+    // So if indices = [2, 0, 1], then 0->2, 2->1, 1->0.
+    // So memory[i] = &memory[indices[i]] is WRONG.
+    // memory[i] should point to memory[next_index].
+    // If indices array IS the permutation, e.g. indices[0]=2 implies 0->2.
+    // Yes, array[i] = &array[indices[i]] works if indices[i] is the 'next' node for node i.
+    
+    for (size_t i = 0; i < num_elements; i++) {
+        memory[i] = &memory[indices[i]];
+    }
+
+    // Warmup
+    void **p = (void**)memory[0];
+    for(int i=0; i<1000; i++) p = (void**)*p;
+
+    struct timespec start, end;
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    
+    // Critical Loop
+    for (size_t i = 0; i < iterations; i++) {
+        p = (void**)*p;
+        // Compiler barrier to force the previous load to complete and prevent loop optimization
+        __asm__ volatile("" : "+r" (p));
+    }
+    
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    
+    // Hand brake to prevent optimization
+    volatile void* result = p; 
+    (void)result;
+
+    double elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
+    
+    
+    free(indices);
+    free(memory);
+    return elapsed;
+}
+
+// Measure sequential access latency
+// Simply walk the array with a stride
+double measure_latency_sequential(size_t size_bytes, size_t iterations) {
+    volatile char *memory = (char*)malloc(size_bytes);
+    if (!memory) return -1.0;
+    
+    // Initialize to force page faults now
+    memset((void*)memory, 0, size_bytes);
+    
+    struct timespec start, end;
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    
+    size_t pos = 0;
+    size_t stride = 64; // Cache Line
+    // volatile ensures the read actually happens
+    
+    for (size_t i = 0; i < iterations; i++) {
+        char v = memory[pos];
+        (void)v; 
+        pos += stride;
+        if (pos >= size_bytes) pos = 0;
+    }
+    
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    double elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
+    
+    free((void*)memory);
+    return elapsed;
+}
+
+// Measure allocation rate
+double measure_alloc_rate(size_t size_bytes, size_t iterations) {
+    struct timespec start, end;
+    
+    // Warmup
+    void *tmp = malloc(size_bytes);
+    free(tmp);
+
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    
+    for (size_t i = 0; i < iterations; i++) {
+        void *p = malloc(size_bytes);
+        if (p) {
+            // Write something to ensure it's not just a virtual reservation (optional, but realistic)
+            *(volatile char*)p = 0; 
+            free(p);
+        }
+    }
+    
+    clock_gettime(CLOCK_MONOTONIC, &end);
+    double elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
+    return elapsed;
+}

benchmarks/system_info.py

@@ -0,0 +1,196 @@
+"""
+System Information Collection Module
+收集系统基础信息：操作系统、CPU、内存、磁盘、GPU
+"""
+
+import platform
+import os
+import psutil
+import cpuinfo
+import time
+from typing import Dict, Any, Optional, List
+
+
+def get_os_info() -> Dict[str, str]:
+    """获取操作系统信息"""
+    try:
+        # 尝试读取 /etc/os-release
+        os_release = {}
+        if os.path.exists('/etc/os-release'):
+            with open('/etc/os-release', 'r') as f:
+                for line in f:
+                    if '=' in line:
+                        key, value = line.strip().split('=', 1)
+                        os_release[key] = value.strip('"')
+
+        # 获取系统负载
+        load_avg = [round(x, 2) for x in os.getloadavg()]
+        
+        # 获取启动时间
+        boot_time = psutil.boot_time()
+        uptime = time.time() - boot_time
+        
+        return {
+            "system": platform.system(),
+            "distro": os_release.get('PRETTY_NAME', platform.platform()),
+            "kernel": platform.release(),
+            "hostname": platform.node(),
+            "architecture": platform.machine(),
+            "load_average": load_avg,
+            "uptime_seconds": int(uptime),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_cpu_info() -> Dict[str, Any]:
+    """获取CPU详细信息"""
+    try:
+        info = cpuinfo.get_cpu_info()
+        
+        # 获取频率信息
+        freq = psutil.cpu_freq()
+        freq_info = {
+            "current_mhz": round(freq.current, 2) if freq else None,
+            "min_mhz": round(freq.min, 2) if freq and freq.min else None,
+            "max_mhz": round(freq.max, 2) if freq and freq.max else None,
+        }
+        
+        # 获取缓存信息
+        cache_info = {}
+        for key in ['l1_data_cache_size', 'l1_instruction_cache_size', 'l2_cache_size', 'l3_cache_size']:
+            if key in info:
+                cache_info[key] = info[key]
+        
+        return {
+            "brand": info.get('brand_raw', 'Unknown'),
+            "arch": info.get('arch', platform.machine()),
+            "bits": info.get('bits', 64),
+            "cores_physical": psutil.cpu_count(logical=False),
+            "cores_logical": psutil.cpu_count(logical=True),
+            "frequency": freq_info,
+            "cache": cache_info,
+            "flags": info.get('flags', [])[:20],  # 只取前20个特性
+            "stats": {
+                "ctx_switches": psutil.cpu_stats().ctx_switches,
+                "interrupts": psutil.cpu_stats().interrupts,
+                "soft_interrupts": psutil.cpu_stats().soft_interrupts,
+            }
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_memory_info() -> Dict[str, Any]:
+    """获取内存信息"""
+    try:
+        mem = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+        
+        def format_bytes(b: int) -> str:
+            """格式化字节数"""
+            for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+                if b < 1024:
+                    return f"{b:.2f} {unit}"
+                b /= 1024
+            return f"{b:.2f} PB"
+        
+        return {
+            "total": mem.total,
+            "total_formatted": format_bytes(mem.total),
+            "available": mem.available,
+            "available_formatted": format_bytes(mem.available),
+            "used": mem.used,
+            "used_formatted": format_bytes(mem.used),
+            "percent": mem.percent,
+            "swap_total": swap.total,
+            "swap_total_formatted": format_bytes(swap.total),
+            "swap_used": swap.used,
+            "swap_percent": swap.percent,
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_disk_info() -> List[Dict[str, Any]]:
+    """获取磁盘信息"""
+    try:
+        disks = []
+        
+        def format_bytes(b: int) -> str:
+            for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+                if b < 1024:
+                    return f"{b:.2f} {unit}"
+                b /= 1024
+            return f"{b:.2f} PB"
+        
+        for partition in psutil.disk_partitions():
+            try:
+                usage = psutil.disk_usage(partition.mountpoint)
+                disks.append({
+                    "device": partition.device,
+                    "mountpoint": partition.mountpoint,
+                    "fstype": partition.fstype,
+                    "total": usage.total,
+                    "total_formatted": format_bytes(usage.total),
+                    "used": usage.used,
+                    "used_formatted": format_bytes(usage.used),
+                    "free": usage.free,
+                    "free_formatted": format_bytes(usage.free),
+                    "percent": usage.percent,
+                })
+            except PermissionError:
+                continue
+        
+        return disks
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+def get_gpu_info() -> Optional[List[Dict[str, Any]]]:
+    """获取GPU信息（如果有NVIDIA GPU）"""
+    try:
+        import subprocess
+        
+        # 尝试运行 nvidia-smi
+        result = subprocess.run(
+            ['nvidia-smi', '--query-gpu=name,memory.total,memory.free,memory.used,driver_version,compute_cap', 
+             '--format=csv,noheader,nounits'],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return None
+        
+        gpus = []
+        for i, line in enumerate(result.stdout.strip().split('\n')):
+            if line:
+                parts = [p.strip() for p in line.split(',')]
+                if len(parts) >= 6:
+                    gpus.append({
+                        "index": i,
+                        "name": parts[0],
+                        "memory_total_mb": int(parts[1]),
+                        "memory_free_mb": int(parts[2]),
+                        "memory_used_mb": int(parts[3]),
+                        "driver_version": parts[4],
+                        "compute_capability": parts[5],
+                    })
+        
+        return gpus if gpus else None
+        
+    except (FileNotFoundError, subprocess.TimeoutExpired, Exception):
+        return None
+
+
+def get_all_system_info() -> Dict[str, Any]:
+    """获取所有系统信息"""
+    return {
+        "os": get_os_info(),
+        "cpu": get_cpu_info(),
+        "memory": get_memory_info(),
+        "disk": get_disk_info(),
+        "gpu": get_gpu_info(),
+    }

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+psutil>=5.9.0
+numpy>=1.24.0
+py-cpuinfo>=9.0.0

static/index.html

@@ -0,0 +1,184 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Space Fetch - System Performance Dashboard</title>
+    <meta name="description" content="Check computer statistics of your Hugging Face Space">
+    <link rel="stylesheet" href="/static/style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+</head>
+<body>
+    <div class="background-effects">
+        <div class="gradient-orb orb-1"></div>
+        <div class="gradient-orb orb-2"></div>
+        <div class="gradient-orb orb-3"></div>
+    </div>
+
+    <div class="container">
+        <header class="header">
+            <div class="logo">
+                <span class="logo-icon">🏆</span>
+                <h1>Space Fetch</h1>
+            </div>
+            <p class="tagline">System Performance Dashboard</p>
+        </header>
+
+        <!-- System Info Section -->
+        <section class="section" id="system-section">
+            <h2 class="section-title">
+                <span class="icon">💻</span>
+                System Information
+            </h2>
+            <div class="cards-grid" id="system-info">
+                <div class="card skeleton">
+                    <div class="skeleton-line"></div>
+                    <div class="skeleton-line short"></div>
+                </div>
+            </div>
+        </section>
+
+        <!-- Hardware Section -->
+        <section class="section" id="hardware-section">
+            <h2 class="section-title">
+                <span class="icon">🔧</span>
+                Hardware Specifications
+            </h2>
+            <div class="hardware-grid" id="hardware-info">
+                <!-- CPU Card -->
+                <div class="hardware-card" id="cpu-card">
+                    <div class="hardware-icon">🖥️</div>
+                    <div class="hardware-content">
+                        <h3>CPU</h3>
+                        <div class="hardware-value" id="cpu-name">Loading...</div>
+                        <div class="hardware-details" id="cpu-details"></div>
+                    </div>
+                </div>
+                
+                <!-- Memory Card -->
+                <div class="hardware-card" id="memory-card">
+                    <div class="hardware-icon">🧠</div>
+                    <div class="hardware-content">
+                        <h3>Memory</h3>
+                        <div class="hardware-value" id="memory-total">Loading...</div>
+                        <div class="progress-bar">
+                            <div class="progress-fill" id="memory-usage" style="width: 0%"></div>
+                        </div>
+                        <div class="hardware-details" id="memory-details"></div>
+                    </div>
+                </div>
+                
+                <!-- Disk Card -->
+                <div class="hardware-card" id="disk-card">
+                    <div class="hardware-icon">💾</div>
+                    <div class="hardware-content">
+                        <h3>Storage</h3>
+                        <div class="hardware-value" id="disk-total">Loading...</div>
+                        <div class="progress-bar">
+                            <div class="progress-fill" id="disk-usage" style="width: 0%"></div>
+                        </div>
+                        <div class="hardware-details" id="disk-details"></div>
+                    </div>
+                </div>
+
+                <!-- GPU Card -->
+                <div class="hardware-card gpu-card" id="gpu-card">
+                    <div class="hardware-icon">🎮</div>
+                    <div class="hardware-content">
+                        <h3>GPU</h3>
+                        <div class="hardware-value" id="gpu-name">Detecting...</div>
+                        <div class="progress-bar">
+                            <div class="progress-fill gpu-fill" id="gpu-usage" style="width: 0%"></div>
+                        </div>
+                        <div class="hardware-details" id="gpu-details"></div>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- Benchmarks Section -->
+        <section class="section" id="benchmark-section">
+            <h2 class="section-title">
+                <span class="icon">⚡</span>
+                Performance Benchmarks
+            </h2>
+            
+            <div class="benchmark-controls">
+                <button class="btn btn-primary" id="run-all-btn" onclick="runAllBenchmarks()">
+                    <span class="btn-icon">🚀</span>
+                    Run Full Benchmark
+                </button>
+                <button class="btn btn-secondary" id="export-btn" onclick="exportResults()">
+                    <span class="btn-icon">📋</span>
+                    Export JSON
+                </button>
+            </div>
+
+            <div class="benchmark-grid" id="benchmark-results">
+                <!-- CPU Benchmark -->
+                <div class="benchmark-card" id="bench-cpu">
+                    <div class="benchmark-header">
+                        <span class="benchmark-icon">🖥️</span>
+                        <h3>CPU Performance</h3>
+                        <button class="btn-mini" onclick="runBenchmark('cpu')" id="run-cpu-btn">Run</button>
+                    </div>
+                    <div class="benchmark-content" id="cpu-bench-content">
+                        <div class="benchmark-placeholder">Click "Run" to start CPU benchmark</div>
+                    </div>
+                </div>
+
+                <!-- Memory Benchmark -->
+                <div class="benchmark-card" id="bench-memory">
+                    <div class="benchmark-header">
+                        <span class="benchmark-icon">🧠</span>
+                        <h3>Memory Performance</h3>
+                        <button class="btn-mini" onclick="runBenchmark('memory')" id="run-memory-btn">Run</button>
+                    </div>
+                    <div class="benchmark-content" id="memory-bench-content">
+                        <div class="benchmark-placeholder">Click "Run" to start Memory benchmark</div>
+                    </div>
+                </div>
+
+                <!-- Disk Benchmark -->
+                <div class="benchmark-card" id="bench-disk">
+                    <div class="benchmark-header">
+                        <span class="benchmark-icon">💾</span>
+                        <h3>Disk I/O Performance</h3>
+                        <button class="btn-mini" onclick="runBenchmark('disk')" id="run-disk-btn">Run</button>
+                    </div>
+                    <div class="benchmark-content" id="disk-bench-content">
+                        <div class="benchmark-placeholder">Click "Run" to start Disk benchmark</div>
+                    </div>
+                </div>
+
+                <!-- GPU Benchmark -->
+                <div class="benchmark-card gpu-bench" id="bench-gpu">
+                    <div class="benchmark-header">
+                        <span class="benchmark-icon">🎮</span>
+                        <h3>GPU Performance</h3>
+                        <button class="btn-mini" onclick="runBenchmark('gpu')" id="run-gpu-btn">Run</button>
+                    </div>
+                    <div class="benchmark-content" id="gpu-bench-content">
+                        <div class="benchmark-placeholder">Click "Run" to start GPU benchmark</div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Overall Score -->
+            <div class="score-card" id="overall-score" style="display: none;">
+                <div class="score-title">Overall Performance Score</div>
+                <div class="score-value" id="total-score">0</div>
+                <div class="score-breakdown" id="score-breakdown"></div>
+            </div>
+        </section>
+
+        <footer class="footer">
+            <p>Space Fetch v1.0.0 | Built for <a href="https://huggingface.co/spaces" target="_blank">Hugging Face Spaces</a></p>
+        </footer>
+    </div>
+
+    <script src="/static/script.js"></script>
+</body>
+</html>

static/script.js

@@ -0,0 +1,305 @@
+/**
+ * Space Fetch - System Performance Dashboard
+ * Frontend Logic
+ */
+
+// Application State
+const state = {
+    systemInfo: null,
+    benchmarks: {
+        cpu: null,
+        memory: null,
+        disk: null,
+        gpu: null
+    },
+    status: {
+        running: {},
+        gpu_available: false
+    }
+};
+
+// Initialization
+document.addEventListener('DOMContentLoaded', async () => {
+    await fetchSystemInfo();
+    await checkBenchmarkStatus();
+
+    // Start polling for active benchmarks
+    setInterval(pollBenchmarkStatus, 2000);
+
+    // Start polling for memory status
+    setInterval(updateMemoryStatus, 1000);
+});
+
+async function fetchSystemInfo() {
+    try {
+        const response = await fetch('/api/system');
+        const data = await response.json();
+        state.systemInfo = data;
+        renderSystemInfo(data);
+        renderHardwareInfo(data);
+    } catch (error) {
+        console.error('Failed to fetch system info:', error);
+    }
+}
+
+async function checkBenchmarkStatus() {
+    try {
+        const response = await fetch('/api/benchmark/status');
+        const data = await response.json();
+        state.status = data;
+
+        // Update GPU card visibility
+        const gpuCard = document.getElementById('gpu-card');
+        const gpuBench = document.getElementById('bench-gpu');
+
+        if (!data.gpu_available) {
+            if (gpuCard) gpuCard.style.display = 'none';
+            if (gpuBench) gpuBench.style.display = 'none';
+        }
+
+        // Restore any running or cached benchmarks
+        for (const [type, isCached] of Object.entries(data.cached)) {
+            if (isCached && !document.getElementById(`${type}-bench-content`).querySelector('.bench-result-item')) {
+                await fetchBenchmarkResult(type);
+            }
+        }
+    } catch (error) {
+        console.error('Failed to check status:', error);
+    }
+}
+
+async function pollBenchmarkStatus() {
+    const response = await fetch('/api/benchmark/status');
+    const data = await response.json();
+
+    // Check for completed benchmarks
+    for (const [type, isRunning] of Object.entries(data.running)) {
+        if (state.status.running[type] && !isRunning) {
+            // Benchmark finished, fetch results
+            await fetchBenchmarkResult(type);
+        }
+
+        // Update button states
+        const btn = document.getElementById(`run-${type}-btn`);
+        if (btn) {
+            if (isRunning) {
+                btn.disabled = true;
+                btn.innerHTML = '<span class="loading-spinner"></span> Running...';
+            } else {
+                btn.disabled = false;
+                btn.innerText = 'Run';
+            }
+        }
+    }
+
+    state.status = data;
+}
+
+async function updateMemoryStatus() {
+    try {
+        const response = await fetch('/api/monitor/memory');
+        if (response.ok) {
+            const data = await response.json();
+            document.getElementById('memory-total').innerText = data.total_formatted;
+            document.getElementById('memory-usage').style.width = `${data.percent}%`;
+            document.getElementById('memory-details').innerText = `${data.used_formatted} used / ${data.available_formatted} available`;
+        }
+    } catch (error) {
+        // Silent fail for polling to avoid console spam
+    }
+}
+
+// Rendering Functions
+function renderSystemInfo(data) {
+    const container = document.getElementById('system-info');
+    container.innerHTML = `
+        <div class="card">
+            <h3>Operating System</h3>
+            <div class="info-row">
+                <span class="info-label">Distro</span>
+                <span class="info-value">${data.os.distro}</span>
+            </div>
+            <div class="info-row">
+                <span class="info-label">Kernel</span>
+                <span class="info-value">${data.os.kernel}</span>
+            </div>
+            <div class="info-row">
+                <span class="info-label">Hostname</span>
+                <span class="info-value">${data.os.hostname}</span>
+            </div>
+            <div class="info-row">
+                <span class="info-label">Load Avg</span>
+                <span class="info-value">${data.os.load_average.join(', ')}</span>
+            </div>
+            <div class="info-row">
+                <span class="info-label">Uptime</span>
+                <span class="info-value">${Math.floor(data.os.uptime_seconds / 3600)}h ${Math.floor((data.os.uptime_seconds % 3600) / 60)}m</span>
+            </div>
+        </div>
+        <div class="card">
+            <h3>Python Environment</h3>
+            <div class="info-row">
+                <span class="info-label">Version</span>
+                <span class="info-value">Python ${data.os.system === 'Linux' ? '3.x' : 'Unknown'}</span>
+            </div>
+            <div class="info-row">
+                <span class="info-label">Architecture</span>
+                <span class="info-value">${data.os.architecture}</span>
+            </div>
+        </div>
+    `;
+}
+
+function renderHardwareInfo(data) {
+    // CPU
+    document.getElementById('cpu-name').innerText = data.cpu.brand;
+    const cpuDetails = `${data.cpu.cores_physical} Physical Cores / ${data.cpu.cores_logical} Logical Cores @ ${data.cpu.frequency.current_mhz || 'N/A'} MHz`;
+    document.getElementById('cpu-details').innerText = cpuDetails;
+
+    // Memory
+    document.getElementById('memory-total').innerText = data.memory.total_formatted;
+    document.getElementById('memory-usage').style.width = `${data.memory.percent}%`;
+    document.getElementById('memory-details').innerText = `${data.memory.used_formatted} used / ${data.memory.available_formatted} available`;
+
+    // Disk (First Partition)
+    if (data.disk.length > 0) {
+        const disk = data.disk[0];
+        document.getElementById('disk-total').innerText = disk.total_formatted;
+        document.getElementById('disk-usage').style.width = `${disk.percent}%`;
+        document.getElementById('disk-details').innerText = `${disk.used_formatted} used / ${disk.free_formatted} free (${disk.mountpoint})`;
+    }
+
+    // GPU
+    if (data.gpu && data.gpu.length > 0) {
+        const gpu = data.gpu[0];
+        document.getElementById('gpu-name').innerText = gpu.name;
+        const memoryUsedPercent = (gpu.memory_used_mb / gpu.memory_total_mb) * 100;
+        document.getElementById('gpu-usage').style.width = `${memoryUsedPercent}%`;
+        document.getElementById('gpu-details').innerText = `${gpu.memory_used_mb}MB / ${gpu.memory_total_mb}MB VRAM | Driver: ${gpu.driver_version}`;
+    } else {
+        const gpuCard = document.getElementById('gpu-card');
+        if (gpuCard) gpuCard.style.display = 'none';
+    }
+}
+
+// Benchmark Actions
+async function runBenchmark(type) {
+    const container = document.getElementById(`${type}-bench-content`);
+    container.innerHTML = `
+        <div class="benchmark-placeholder">
+            <span class="loading-spinner"></span><br>
+            Running benchmark... This may take a moment.
+        </div>
+    `;
+
+    try {
+        await fetch(`/api/benchmark/${type}`, { method: 'POST' });
+        // Polling will handle the update
+    } catch (error) {
+        container.innerHTML = `<div class="benchmark-placeholder" style="color: var(--danger-color)">Error starting benchmark</div>`;
+    }
+}
+
+async function runAllBenchmarks() {
+    const types = ['cpu', 'memory', 'disk'];
+    if (state.status.gpu_available) types.push('gpu');
+
+    for (const type of types) {
+        runBenchmark(type);
+    }
+}
+
+async function fetchBenchmarkResult(type) {
+    try {
+        const response = await fetch(`/api/benchmark/${type}`);
+        const data = await response.json();
+
+        if (data.results) {
+            renderBenchmarkResult(type, data.results);
+        }
+    } catch (error) {
+        console.error(`Error details for ${type}:`, error);
+    }
+}
+
+function renderBenchmarkResult(type, results) {
+    const container = document.getElementById(`${type}-bench-content`);
+    let html = '';
+
+    if (type === 'cpu') {
+        html += createResultItem('Single Core Integer', `${results.single_core_integer.ops_per_second} ops/s`, results.single_core_integer.score);
+        html += createResultItem('Multi Core Integer', `${results.multi_core_integer.ops_per_second} ops/s`, results.multi_core_integer.score);
+        html += createResultItem('Single Core Float', `${results.single_core_float.gflops} GFLOPS`, results.single_core_float.score);
+        html += createResultItem('Multi Core Float', `${results.multi_core_float.gflops} GFLOPS`, results.multi_core_float.score);
+        html += createResultItem('SHA256 Hash', `${results.crypto.throughput_mb_per_sec} MB/s`, results.crypto.score);
+        html += createResultItem('Zlib Compression', `${results.compression.throughput_mb_per_sec} MB/s`, results.compression.score);
+        html += createResultItem('Context Switches', `${results.stress.wakeups_per_second} /s`, results.stress.score);
+    } else if (type === 'memory') {
+        html += createResultItem('Read Bandwidth', `${results.bandwidth.read_bandwidth_gb_s} GB/s`);
+        html += createResultItem('Write Bandwidth', `${results.bandwidth.write_bandwidth_gb_s} GB/s`);
+
+        // New Metric structure
+        if (results.latency_random) {
+            html += createResultItem('Random Latency', `${results.latency_random.average_latency_ns} ns`);
+        }
+        if (results.latency_sequential) {
+            html += createResultItem('Seq Latency', `${results.latency_sequential.average_latency_ns} ns`);
+        }
+        if (results.alloc_rate) {
+            html += createResultItem('Alloc Rate', `${(results.alloc_rate.ops_per_sec / 1e6).toFixed(1)} M/s`);
+        }
+        if (results.cache_latency && results.cache_latency.levels) {
+            const l1 = results.cache_latency.levels.L1;
+            const l2 = results.cache_latency.levels.L2;
+            const l3 = results.cache_latency.levels.L3;
+            html += createResultItem('L1 Latency', `${l1.latency_ns} ns`);
+            html += createResultItem('L2 Latency', `${l2.latency_ns} ns`);
+            html += createResultItem('L3 Latency', `${l3.latency_ns} ns`);
+        }
+    } else if (type === 'disk') {
+        html += createResultItem('Seq Read', `${results.sequential_read.throughput_mb_s} MB/s`, results.sequential_read.score);
+        html += createResultItem('Seq Write', `${results.sequential_write.throughput_mb_s} MB/s`, results.sequential_write.score);
+        html += createResultItem('Random Read', `${results.random_read_iops.iops} IOPS`, results.random_read_iops.score);
+        html += createResultItem('Random Write', `${results.random_write_iops.iops} IOPS`, results.random_write_iops.score);
+    } else if (type === 'gpu') {
+        if (results.memory_bandwidth) html += createResultItem('Memory Bandwidth', `${results.memory_bandwidth.bandwidth_gb_s} GB/s`, results.memory_bandwidth.score);
+        if (results.fp32) html += createResultItem('FP32 Compute', `${results.fp32.tflops} TFLOPS`, results.fp32.score);
+        if (results.fp16) html += createResultItem('FP16 Compute', `${results.fp16.tflops} TFLOPS`, results.fp16.score);
+        if (results.tensor_cores) html += createResultItem('Tensor Cores', `${results.tensor_cores.tflops} TFLOPS`, results.tensor_cores.score);
+    }
+
+    container.innerHTML = html;
+}
+
+function createResultItem(label, value, score) {
+    return `
+        <div class="bench-result-item">
+            <div class="bench-label">
+                <span>${label}</span>
+            </div>
+            <div class="progress-bar" style="height: 4px; margin: 2px 0;">
+                <div class="progress-fill" style="width: 100%; opacity: 0.5;"></div>
+            </div>
+            <div class="bench-value">${value}</div>
+        </div>
+    `;
+}
+
+async function exportResults() {
+    try {
+        const response = await fetch('/api/export');
+        const data = await response.json();
+
+        const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `space-fetch-results-${new Date().toISOString().slice(0, 10)}.json`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    } catch (error) {
+        alert('Failed to export results');
+    }
+}

static/style.css

@@ -0,0 +1,400 @@
+/* Global Styles */
+:root {
+    --bg-color: #0d1117;
+    --card-bg: rgba(22, 27, 34, 0.7);
+    --text-primary: #e6edf3;
+    --text-secondary: #8b949e;
+    --accent-color: #58a6ff;
+    --success-color: #3fb950;
+    --warning-color: #d29922;
+    --danger-color: #f85149;
+    --border-color: #30363d;
+    --gpu-color: #76e191;
+    
+    --font-heading: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    --font-mono: 'JetBrains Mono', monospace;
+}
+
+body {
+    margin: 0;
+    padding: 0;
+    background-color: var(--bg-color);
+    color: var(--text-primary);
+    font-family: var(--font-heading);
+    line-height: 1.6;
+    min-height: 100vh;
+    overflow-x: hidden;
+}
+
+/* Background Effects */
+.background-effects {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: -1;
+    overflow: hidden;
+}
+
+.gradient-orb {
+    position: absolute;
+    border-radius: 50%;
+    filter: blur(100px);
+    opacity: 0.15;
+    animation: float 20s infinite ease-in-out;
+}
+
+.orb-1 {
+    top: -10%;
+    left: -10%;
+    width: 600px;
+    height: 600px;
+    background: radial-gradient(circle, #58a6ff, #1f6feb);
+}
+
+.orb-2 {
+    bottom: -10%;
+    right: -10%;
+    width: 700px;
+    height: 700px;
+    background: radial-gradient(circle, #7e3ddb, #a371f7);
+    animation-delay: -5s;
+}
+
+.orb-3 {
+    top: 40%;
+    left: 40%;
+    width: 500px;
+    height: 500px;
+    background: radial-gradient(circle, #3fb950, #2ea043);
+    animation-delay: -10s;
+}
+
+@keyframes float {
+    0%, 100% { transform: translate(0, 0); }
+    33% { transform: translate(50px, -50px); }
+    66% { transform: translate(-30px, 30px); }
+}
+
+/* Container */
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+/* Header */
+.header {
+    text-align: center;
+    margin-bottom: 4rem;
+    animation: fadeIn 1s ease-out;
+}
+
+.logo h1 {
+    font-size: 3rem;
+    margin: 0;
+    background: linear-gradient(135deg, #fff 0%, #a5d6ff 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    display: inline-block;
+}
+
+.logo-icon {
+    font-size: 3rem;
+    margin-right: 1rem;
+    vertical-align: middle;
+}
+
+.tagline {
+    color: var(--text-secondary);
+    font-size: 1.2rem;
+    margin-top: 0.5rem;
+}
+
+/* Sections */
+.section {
+    margin-bottom: 4rem;
+    animation: slideUp 0.8s ease-out;
+}
+
+.section-title {
+    font-size: 1.8rem;
+    margin-bottom: 1.5rem;
+    display: flex;
+    align-items: center;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: 1rem;
+}
+
+.section-title .icon {
+    margin-right: 0.8rem;
+}
+
+/* Cards */
+.card, .hardware-card, .benchmark-card, .score-card {
+    background: var(--card-bg);
+    backdrop-filter: blur(10px);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    padding: 1.5rem;
+    transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.card:hover, .hardware-card:hover, .benchmark-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.2);
+    border-color: var(--accent-color);
+}
+
+/* Hardware Grid */
+.hardware-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 1.5rem;
+}
+
+.hardware-card {
+    display: flex;
+    flex-direction: column;
+}
+
+.hardware-icon {
+    font-size: 2rem;
+    margin-bottom: 1rem;
+}
+
+.hardware-content h3 {
+    margin: 0 0 0.5rem 0;
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+}
+
+.hardware-value {
+    font-size: 1.2rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.hardware-details {
+    margin-top: auto;
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+    line-height: 1.4;
+}
+
+/* Progress Bars */
+.progress-bar {
+    width: 100%;
+    height: 6px;
+    background: rgba(255, 255, 255, 0.1);
+    border-radius: 3px;
+    margin: 0.5rem 0;
+    overflow: hidden;
+}
+
+.progress-fill {
+    height: 100%;
+    background: var(--accent-color);
+    border-radius: 3px;
+    transition: width 1s ease-in-out;
+}
+
+.gpu-fill {
+    background: var(--gpu-color);
+}
+
+/* System Info List */
+.info-row {
+    display: flex;
+    justify-content: space-between;
+    padding: 0.5rem 0;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.info-label {
+    color: var(--text-secondary);
+}
+
+.info-value {
+    font-family: var(--font-mono);
+    color: var(--accent-color);
+}
+
+/* Benchmarks */
+.benchmark-controls {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 2rem;
+}
+
+.btn {
+    padding: 0.8rem 1.5rem;
+    border-radius: 6px;
+    border: none;
+    font-weight: 600;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    transition: all 0.2s;
+}
+
+.btn-primary {
+    background: var(--accent-color);
+    color: #fff;
+}
+
+.btn-primary:hover {
+    background: #3a8cf0;
+    transform: scale(1.02);
+}
+
+.btn-secondary {
+    background: rgba(255, 255, 255, 0.1);
+    color: var(--text-primary);
+}
+
+.btn-secondary:hover {
+    background: rgba(255, 255, 255, 0.15);
+}
+
+.btn-icon {
+    margin-right: 0.5rem;
+}
+
+.btn-mini {
+    background: rgba(255, 255, 255, 0.1);
+    border: 1px solid var(--border-color);
+    color: var(--text-primary);
+    padding: 0.3rem 0.8rem;
+    border-radius: 4px;
+    font-size: 0.8rem;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.btn-mini:hover {
+    background: var(--accent-color);
+    border-color: var(--accent-color);
+}
+
+.btn-mini:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.benchmark-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+    gap: 1.5rem;
+}
+
+.benchmark-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.benchmark-header h3 {
+    margin: 0;
+    display: flex;
+    align-items: center;
+    font-size: 1.1rem;
+}
+
+.benchmark-icon {
+    margin-right: 0.5rem;
+}
+
+.benchmark-placeholder {
+    color: var(--text-secondary);
+    text-align: center;
+    padding: 2rem 0;
+    font-style: italic;
+}
+
+/* Benchmark Result Items */
+.bench-result-item {
+    margin-bottom: 1rem;
+}
+
+.bench-label {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 0.3rem;
+    font-size: 0.9rem;
+}
+
+.bench-score {
+    font-family: var(--font-mono);
+    color: var(--warning-color);
+}
+
+.bench-value {
+    color: var(--success-color);
+    font-weight: 500;
+}
+
+/* Animations */
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes slideUp {
+    from { transform: translateY(20px); opacity: 0; }
+    to { transform: translateY(0); opacity: 1; }
+}
+
+.loading-spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid rgba(255, 255, 255, 0.3);
+    border-radius: 50%;
+    border-top-color: var(--accent-color);
+    animation: spin 1s ease-in-out infinite;
+    margin-right: 0.5rem;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Skeleton Loading */
+.skeleton {
+    animation: pulse 1.5s infinite;
+}
+
+.skeleton-line {
+    height: 20px;
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 4px;
+    margin-bottom: 0.5rem;
+}
+
+.skeleton-line.short {
+    width: 60%;
+}
+
+@keyframes pulse {
+    0% { opacity: 0.6; }
+    50% { opacity: 1; }
+    100% { opacity: 0.6; }
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .header h1 {
+        font-size: 2rem;
+    }
+    
+    .hardware-grid, .benchmark-grid {
+        grid-template-columns: 1fr;
+    }
+}