bench

type Backend string

type Config struct {
	Backends    []Backend     // which substrates to run (default: memory, file)
	Concurrency int           // load workers
	Duration    time.Duration // load phase per backend
	Density     int           // extra warm functions deployed for the density sweep
	MemBudgetMB int           // function-memory budget for the verdict (e.g. 16384)
	TargetFns   int           // agents to size for (e.g. 100)
}

type ContainerdConfig struct {
	Socket      string // containerd socket to dial (ADR-0054 Manager-provided)
	Namespace   string // isolated containerd namespace for the lane's throwaway containers (ADR-0055 dedicated-box); "" ⇒ "funcd-bench"
	Snapshotter string // overlayfs
	CNIBinDir   string // /opt/cni/bin
	CNIConfDir  string // funcd-written conflist dir
	SubnetCIDR  string // lateral bridge subnet
	ImagePrefix string // "funcd/runtime-"; image = prefix + runtime + ":latest"

	// ImageOverride maps a runtime to the registry ref the lane runs instead (ctrmanager.Config.ImageFor).
	ImageOverride map[string]string

	// ShimPath is the in-container shim cmdline token (the curated image's entrypoint —
	// "/opt/funcd/shim.mjs", ADR-0032). The container processes are host-visible PIDs, so
	// shimRSSMB(ShimPath) sums the SAME containers' RSS — a same-population cgroup-vs-RSS ratio.
	ShimPath string

	Density     int           // extra warm functions for the marginal-cgroup sweep
	MemBudgetMB int           // function-memory budget for the verdict
	TargetFns   int           // agents to size for
	Concurrency int           // load workers
	Duration    time.Duration // load phase
}

type FootprintReport struct {
	Skipped    bool   `json:"skipped"`
	SkipReason string `json:"skipReason,omitempty"`

	PerFunctionCgroupMB float64 `json:"perFunctionCgroupMB"` // marginal cgroup memory.current / fn (the true footprint)
	PerFunctionRSSMB    float64 `json:"perFunctionRSSMB"`    // marginal RSS of the SAME container processes (the baseline)
	CgroupOverRSS       float64 `json:"cgroupOverRSS"`       // container cgroup ÷ RSS — how much process RSS under-counts
	PlatformBaselineMB  float64 `json:"platformBaselineMB"`  // funcd control-plane RSS
	MaxDensity          int     `json:"maxDensity"`          // functions within MemBudgetMB, from the cgroup number (honest)
	FitsTarget          bool    `json:"fitsTarget"`          // TargetFns within MemBudgetMB? — NOT optimistic (cgroup-measured)
	RPS                 float64 `json:"rps"`
	Latency             Latency `json:"latency"`
}

type Latency struct {
	P50  time.Duration `json:"p50"`
	P90  time.Duration `json:"p90"`
	P99  time.Duration `json:"p99"`
	P999 time.Duration `json:"p999"`
	Max  time.Duration `json:"max"`
}

type PoolComparison struct {
	K         int     `json:"k"`
	Substrate Backend `json:"substrate"`
	// density (stable, primary)
	PerFunctionMB float64 `json:"perFunctionMB"`       // marginal RSS of one more separate shim
	PooledMBPerFn float64 `json:"pooledMBPerFunction"` // pool RSS / K
	DensityGain   float64 `json:"densityGain"`         // perFunctionMB / pooledMBPerFn
	// throughput (indicative) — both measured DIRECTLY on the shim port (no data plane)
	SingleDirectRPS    float64       `json:"singleDirectRPS"`    // one single-tenant shim, direct — HIGH VARIANCE
	SingleDirectP99    time.Duration `json:"singleDirectP99"`    //
	PooledRPS          float64       `json:"pooledRPS"`          // one handler in the pool, direct (stable)
	PooledP99          time.Duration `json:"pooledP99"`          //
	ThroughputRetained float64       `json:"throughputRetained"` // pooledRPS / singleDirectRPS — indicative only
}

type PyPoolComparison struct {
	K             int           `json:"k"`
	Python        string        `json:"python"`
	SoloMBPerFn   float64       `json:"soloMBPerFunction"`   // one solo shim's RSS = a function's marginal cost
	PooledMBPerFn float64       `json:"pooledMBPerFunction"` // pool host RSS / K
	DensityGain   float64       `json:"densityGain"`         // soloMBPerFn / pooledMBPerFn
	SoloRPS       float64       `json:"soloRPS"`
	SoloP99       time.Duration `json:"soloP99"`
	PooledRPS     float64       `json:"pooledRPS"`
	PooledP99     time.Duration `json:"pooledP99"`
}

type Report struct {
	Backend             Backend       `json:"backend"`
	RPS                 float64       `json:"rps"`
	Latency             Latency       `json:"latency"`
	PlatformBaselineMB  float64       `json:"platformBaselineMB"`
	PerWorkerMB         float64       `json:"perWorkerMB"`
	IdleMB              float64       `json:"idleMB"`              // shim RSS while the only fn is scaled-to-zero (≈0 ⇒ reclaim works)
	ColdStart           time.Duration `json:"coldStart"`           // wake → first response (timed only after 0 replicas)
	PerFunctionMB       float64       `json:"perFunctionMB"`       // marginal slope: (RSS_at_K − perWorker) / K
	MaxDensity          int           `json:"maxDensity"`          // functions within MemBudgetMB
	FitsTarget          bool          `json:"fitsTarget"`          // TargetFns within MemBudgetMB? (optimistic — process RSS < cgroup)
	PooledPerFunctionMB float64       `json:"pooledPerFunctionMB"` // same K handlers in ONE worker_threads pool / K (ADR-0044); 0 if not measured
	PooledRPS           float64       `json:"pooledRPS"`           // throughput at one handler IN the pool, hit DIRECTLY (the worker_threads path); 0 if not measured
	PooledLatency       Latency       `json:"pooledLatency"`       // tail latency at one pooled handler, direct — the structured-clone cost
	SingleDirectRPS     float64       `json:"singleDirectRPS"`     // throughput of ONE single-tenant shim on the SAME direct path — the fair baseline for the pool
	SingleDirectLatency Latency       `json:"singleDirectLatency"` // tail latency of the single-tenant shim, same direct path
	PooledK             int           `json:"pooledK"`             // pool size the pooled numbers were measured at
}