bench

type Baseline struct {
	NaiveBitsPerURL  float64 // 128, the exact-key floor of a naive frontier
	MeguriBitsPerURL float64 // measured seen-set bits/url
	MemoryRatio      float64 // naive / meguri, the paired ratio
	NaiveFleetBytes  float64 // naive bits/url x TotalURLs / 8
	MeguriFleetBytes float64 // meguri bits/url x TotalURLs / 8
	Calc             string  // the paired multiplication, shown

	// The approximate-membership model arm: a plain bloom filter sized to hit
	// meguri's own measured false-positive rate, computed from the optimal-bloom
	// formula m/n = -ln(p)/(ln2)^2, not run. It is the fair lower bound on any
	// approximate set at the same accuracy, and the gap to meguri's measured cost is
	// the premium meguri pays for the exact tier (zero false negatives plus the
	// ability to enumerate), named not hidden. Zero when no FP rate was measured.
	BloomFPRate       float64 // the FP rate the bloom is sized for, meguri's own
	BloomBitsPerURL   float64 // optimal bloom bits/url at BloomFPRate
	BloomFleetBytes   float64 // bloom bits/url x TotalURLs / 8
	MeguriPremiumBits float64 // meguri bits/url minus the bloom optimum
}

type HostKeyRange struct {
	Lo    uint64
	Hi    uint64
	Hosts int
}

type Measured struct {
	URLs      int // distinct urls in the partition, the divisor for every per-url cost
	Hosts     int // distinct hosts
	FileBytes int // the encoded .meguri size

	BytesPerURL float64      // FileBytes / URLs, the section 3.8 redistribution number
	Regions     []RegionCost // per-region byte breakdown from the footer directory

	SeenSetBits int     // resident filter bits over the held keys
	BitsPerURL  float64 // SeenSetBits / URLs, the section 3.7 seen-set number

	FPProbes       int     // held-out keys probed for a filter false positive
	FPHits         int     // probes the filter false-positived on
	FPRate         float64 // FPHits / FPProbes, the rate achieved at BitsPerURL
	FalseNegatives int     // held keys the one-sided filter missed; must be 0
}

type PolitenessPoint struct {
	ActiveHosts int
	CeilingFPS  float64
}

type Projection struct {
	TotalURLs        float64 // the canon scale target, 100 billion
	URLsPerPartition float64 // the pinned per-partition capacity, the lever
	PartitionCount   float64 // TotalURLs / URLsPerPartition, derived not assumed

	SeenSetFleetBytes float64 // measured bits/url x TotalURLs / 8
	SeenSetFleetCalc  string  // the multiplication, shown
	SeenSetPerPart    float64 // SeenSetFleetBytes / PartitionCount, the per-machine share

	MeguriFleetBytes float64 // measured bytes/url x TotalURLs
	MeguriFleetCalc  string  // the multiplication, shown
	MeguriPerPart    float64 // MeguriFleetBytes / PartitionCount, one file per partition
}

type RebalanceCost struct {
	NewParts      int     // partitions the fleet grew to (the source was partition 0)
	SourceHosts   int     // hosts on the source before the move
	SourceURLs    int     // URLs on the source before the move
	SourceBytes   int     // encoded .meguri size of the source
	MovedHosts    int     // hosts that changed owner and ship out
	MovedURLs     int     // URLs carried by the moved hosts
	ShippedBytes  int     // encoded .meguri size of all the ship slices
	Destinations  int     // distinct new owners the source ships to
	MovedFraction float64 // ShippedBytes / SourceBytes
	BandwidthMBps float64 // the device-bandwidth floor the caller names
	TransferSec   float64 // ShippedBytes / (BandwidthMBps x 1e6)
	Calc          string  // the shown division
}

type RegionCost struct {
	Name        string
	Bytes       uint64
	BytesPerURL float64
}

type Throughput struct {
	SchedulerFPS     float64           // measured scheduler selections/s, the operator's benchstat figure
	PoliteCeilingFPS float64           // sum over all hosts of 1/crawl_delay, the partition's polite ceiling
	MedianHostFPS    float64           // 1/crawl_delay at the median host, the per-host floor
	ActiveHosts      int               // hosts with a crawl delay, the ceiling's host count
	FetcherBoundGap  float64           // SchedulerFPS / PoliteCeilingFPS, how many times the scheduler outruns this host set
	HostsToSaturate  float64           // active hosts (at the median delay) needed before the scheduler stops being the slack
	Curve            []PolitenessPoint // the ceiling at a few active-host counts
}

type Wall struct {
	Name    string
	Formula string
	Note    string
}