streaming

type AdaptivePlanner struct {
	// contains filtered or unexported fields
}

type AdaptiveStats struct {
	ReplanCount       int
	FinalGrowthRate   float64
	InitialGrowthRate float64
	FinalWorkGrowth   float64
	FinalTCSize       float64
	FinalAggGrowth    float64
}

type ChunkBounds struct {
	Start int // Inclusive index.
	End   int // Exclusive index.
}

type ChunkMemoryLog struct {
	ChunkIndex      int
	HeapBefore      int64
	HeapAfter       int64
	SysAfter        int64
	BudgetUsedPct   float64
	GrowthPerCommit int64
	EMAGrowthRate   float64
	Replanned       bool
}

type HeapSnapshot struct {
	HeapInuse int64
	HeapAlloc int64
	Sys       int64 // Total bytes obtained from the OS (Go runtime).
	NumGC     uint32
	TakenAtNS int64
}

type Hibernatable interface {
	// Hibernate compresses the analyzer's state to reduce memory usage.
	// Called between chunks during streaming execution.
	Hibernate() error

	// Boot restores the analyzer from hibernated state.
	// Called before processing a new chunk after hibernation.
	Boot() error
}

type MemoryPressureLevel int

type Planner struct {
	TotalCommits int
	MemoryBudget int64

	// AggregateGrowthPerCommit is the summed per-commit state growth across all
	// selected leaf analyzers. When zero, DefaultStateGrowthPerCommit is used.
	AggregateGrowthPerCommit int64

	// PipelineOverhead is the estimated memory consumed by caches, workers, and
	// buffers (everything except analyzer state). When positive, it replaces
	// BaseOverhead for more accurate chunk sizing. The budget solver provides
	// this value via EstimateMemoryUsage.
	PipelineOverhead int64
}

type ReplanObservation struct {
	// ChunkIndex is the zero-based index of the chunk just processed.
	ChunkIndex int

	// Chunk is the bounds of the chunk just processed.
	Chunk ChunkBounds

	// WorkGrowthPerCommit is the observed per-commit working state growth in bytes.
	// Computed as (HeapInuse delta - aggregator state delta) / commits.
	WorkGrowthPerCommit int64

	// TCPayloadPerCommit is the observed per-commit TC payload size in bytes.
	TCPayloadPerCommit int64

	// AggGrowthPerCommit is the observed per-commit aggregator state growth in bytes.
	AggGrowthPerCommit int64

	// CurrentChunks is the current chunk plan (including already-processed chunks).
	CurrentChunks []ChunkBounds
}

type Schedule struct {
	// Chunks are the planned chunk boundaries.
	Chunks []ChunkBounds

	// ChunkSize is the number of commits per chunk (last chunk may be smaller).
	ChunkSize int

	// BufferingFactor is the pipelining factor (1=single, 2=double, 3=triple).
	BufferingFactor int

	// AggSpillBudget is the maximum bytes of aggregator state before spilling.
	// Zero means no limit (unlimited budget or budget too small).
	AggSpillBudget int64
}

type SchedulerConfig struct {
	// TotalCommits is the number of commits to process.
	TotalCommits int

	// MemoryBudget is the user-specified memory budget in bytes. Zero means unlimited.
	MemoryBudget int64

	// PipelineOverhead is the estimated fixed overhead for the pipeline
	// (workers, caches, buffers). When zero, BaseOverhead is used.
	PipelineOverhead int64

	// WorkStatePerCommit is the per-commit working state growth in bytes.
	// When zero, DefaultWorkingStateSize is used.
	WorkStatePerCommit int64

	// AvgTCSize is the average TC payload size per commit in bytes.
	// Currently informational; used for future chunkMem sizing.
	AvgTCSize int64

	// MaxBuffering is the maximum buffering factor (1=single, 2=double, 3=triple).
	// The scheduler iterates from MaxBuffering down to 1, selecting the highest
	// factor where ChunkSize >= MinChunkSize. When zero or negative, treated as 1.
	MaxBuffering int
}

type SpillCleaner interface {
	CleanupSpills()
}

type SpillCleanupGuard struct {
	// contains filtered or unexported fields
}