Skip to content

Project NOMAD is an offline-first knowledge and education server. Wikipedia, thousands of books, courses, maps, and optional local AI, all running on hardware you own with no internet required.

TypeScript
6.3 KB
Raw Blame
import { useCallback, useEffect, useRef, useState } from 'react'
import { useTransmit } from 'react-adonis-transmit'
import { BROADCAST_CHANNELS } from '../../constants/broadcast'
import type {
  BenchmarkProgress,
  BenchmarkTelemetry,
  BenchmarkStatus,
  BenchmarkStageDescriptor,
  BenchmarkPartialResult,
} from '../../types/benchmark'

// Rolling window length for the sparklines (~1 minute at 1 Hz).
const RING = 60

export type BenchmarkProgressWithID = BenchmarkProgress & { benchmark_id: string }

type LiveState = {
  perCore: number[]
  cpuOverall: number
  cpuHistory: number[]
  tempC: number | null
  diskReadMbs: number
  diskWriteMbs: number
  diskReadHistory: number[]
  diskWriteHistory: number[]
  aiTokensPerSec: number | null
  aiTokHistory: number[]
  aiTtftMs: number | null
  cpuEventsPerSec: number | null
  cpuEventsHistory: number[]
  /** Authoritative in-test disk throughput (sysbench interim lines), MiB/s. */
  diskMibs: number | null
  diskMibsHistory: number[]
  /** NVIDIA GPU stats during the AI stage (null when no GPU / not sampling). */
  gpuUtil: number | null
  gpuVramUsedMb: number | null
  gpuVramTotalMb: number | null
}

const EMPTY_LIVE: LiveState = {
  perCore: [],
  cpuOverall: 0,
  cpuHistory: [],
  tempC: null,
  diskReadMbs: 0,
  diskWriteMbs: 0,
  diskReadHistory: [],
  diskWriteHistory: [],
  aiTokensPerSec: null,
  aiTokHistory: [],
  aiTtftMs: null,
  cpuEventsPerSec: null,
  cpuEventsHistory: [],
  diskMibs: null,
  diskMibsHistory: [],
  gpuUtil: null,
  gpuVramUsedMb: null,
  gpuVramTotalMb: null,
}

const pushRing = (arr: number[], v: number) => {
  const next = arr.length >= RING ? arr.slice(arr.length - RING + 1) : arr.slice()
  next.push(v)
  return next
}

/**
 * Owns the two benchmark SSE subscriptions (stage progress + high-rate
 * telemetry) and exposes a flat, render-ready view of a live run. All history
 * buffers are kept as fresh arrays so memoized children re-render on change.
 */
export function useBenchmarkRun(opts?: { onFinished?: (status: 'completed' | 'error', message: string) => void }) {
  const { subscribe } = useTransmit()
  const onFinishedRef = useRef(opts?.onFinished)
  onFinishedRef.current = opts?.onFinished

  const [progress, setProgress] = useState<BenchmarkProgressWithID | null>(null)
  const [live, setLive] = useState<LiveState>(EMPTY_LIVE)
  const [partials, setPartials] = useState<BenchmarkPartialResult[]>([])
  // Last-seen progress status, so stage transitions can reset in-test buffers.
  const lastStatusRef = useRef<BenchmarkStatus | null>(null)

  const reset = useCallback(() => {
    setProgress(null)
    setLive(EMPTY_LIVE)
    setPartials([])
    lastStatusRef.current = null
  }, [])

  useEffect(() => {
    const unsubProgress = subscribe(
      BROADCAST_CHANNELS.BENCHMARK_PROGRESS,
      (data: BenchmarkProgressWithID) => {
        setProgress(data)
        // On stage transition, clear the in-test buffers so each stage starts
        // clean (e.g. the disk-read throughput doesn't linger into the write
        // stage). Always-on host telemetry (perCore, cpuOverall, disk proxy,
        // temp) is intentionally left untouched.
        if (lastStatusRef.current !== data.status) {
          lastStatusRef.current = data.status
          setLive((prev) => ({
            ...prev,
            cpuEventsPerSec: null,
            cpuEventsHistory: [],
            diskMibs: null,
            diskMibsHistory: [],
          }))
        }
        if (data.partial_result) {
          const incoming = data.partial_result
          setPartials((prev) => {
            const idx = prev.findIndex((p) => p.status === incoming.status)
            if (idx >= 0) {
              const next = prev.slice()
              next[idx] = incoming
              return next
            }
            return [...prev, incoming]
          })
        }
        if (data.status === 'completed' || data.status === 'error') {
          onFinishedRef.current?.(data.status, data.message)
        }
      }
    )

    const unsubTelemetry = subscribe(
      BROADCAST_CHANNELS.BENCHMARK_TELEMETRY,
      (data: BenchmarkTelemetry) => {
        setLive((prev) => {
          const isTok = data.stage_metric?.kind === 'tokens_per_sec'
          const isEps = data.stage_metric?.kind === 'events_per_sec'
          const isMib = data.stage_metric?.kind === 'mib_s'
          return {
            perCore: data.cpu.per_core,
            cpuOverall: data.cpu.overall,
            cpuHistory: pushRing(prev.cpuHistory, data.cpu.overall),
            tempC: data.temp_c,
            diskReadMbs: data.disk.read_mb_s,
            diskWriteMbs: data.disk.write_mb_s,
            diskReadHistory: pushRing(prev.diskReadHistory, data.disk.read_mb_s),
            diskWriteHistory: pushRing(prev.diskWriteHistory, data.disk.write_mb_s),
            aiTokensPerSec: isTok ? data.stage_metric!.value : prev.aiTokensPerSec,
            aiTokHistory: isTok ? pushRing(prev.aiTokHistory, data.stage_metric!.value) : prev.aiTokHistory,
            aiTtftMs: isTok && data.stage_metric!.ttft_ms !== undefined ? data.stage_metric!.ttft_ms : prev.aiTtftMs,
            cpuEventsPerSec: isEps ? data.stage_metric!.value : prev.cpuEventsPerSec,
            cpuEventsHistory: isEps
              ? pushRing(prev.cpuEventsHistory, data.stage_metric!.value)
              : prev.cpuEventsHistory,
            diskMibs: isMib ? data.stage_metric!.value : prev.diskMibs,
            diskMibsHistory: isMib
              ? pushRing(prev.diskMibsHistory, data.stage_metric!.value)
              : prev.diskMibsHistory,
            gpuUtil: data.gpu ? data.gpu.util : prev.gpuUtil,
            gpuVramUsedMb: data.gpu ? data.gpu.vram_used_mb : prev.gpuVramUsedMb,
            gpuVramTotalMb: data.gpu ? data.gpu.vram_total_mb : prev.gpuVramTotalMb,
          }
        })
      }
    )

    return () => {
      unsubProgress()
      unsubTelemetry()
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [subscribe])

  const status: BenchmarkStatus | null = progress?.status ?? null
  const stages: BenchmarkStageDescriptor[] = progress?.stages ?? []
  const stageIndex = progress?.stage_index ?? -1

  return {
    progress,
    status,
    stages,
    stageIndex,
    message: progress?.message ?? '',
    progressPercent: progress?.progress ?? 0,
    ...live,
    partials,
    reset,
  }
}

export type BenchmarkRunHook = ReturnType<typeof useBenchmarkRun>