resource

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

type Capacity struct {
	// SlotsTotal is how many jobs the sensor runs at once now (dynamic, at
	// most the configured cap).
	SlotsTotal int `json:"slots_total"`
	// SlotsFree is SlotsTotal minus ActiveJobs (never negative).
	SlotsFree int `json:"slots_free"`
	// ActiveJobs is the jobs it holds now.
	ActiveJobs int `json:"active_jobs"`
	// PerTool is the per-job cost of each tool the sensor runs.
	PerTool map[string]ToolEstimate `json:"per_tool,omitempty"`
}

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

type ControllerConfig struct {
	// CPUThreshold is the CPU percentage above which new work is paused.
	// Default: 85%
	CPUThreshold float64

	// MemoryThreshold is the memory percentage above which new work is paused.
	// Default: 85%
	MemoryThreshold float64

	// MaxConcurrentJobs limits the number of concurrent jobs.
	// Default: runtime.NumCPU()
	MaxConcurrentJobs int

	// MinConcurrentJobs is the minimum jobs to allow even under load.
	// Default: 1
	MinConcurrentJobs int

	// SampleInterval is how often to sample system metrics.
	// Default: 5 seconds
	SampleInterval time.Duration

	// CooldownDuration is how long to wait after threshold exceeded.
	// Default: 30 seconds
	CooldownDuration time.Duration

	// OnThresholdExceeded is called when resource threshold is exceeded.
	OnThresholdExceeded func(metrics *SystemMetrics, reason string)

	// OnThresholdCleared is called when resources return to normal.
	OnThresholdCleared func(metrics *SystemMetrics)

	// Verbose enables debug logging.
	Verbose bool
}

type ControllerStatus struct {
	Throttled      bool           `json:"throttled"`
	ThrottledAt    time.Time      `json:"throttled_at,omitempty"`
	ThrottleReason string         `json:"throttle_reason,omitempty"`
	ActiveJobs     int            `json:"active_jobs"`
	PendingJobs    int            `json:"pending_jobs"`
	RejectedJobs   int64          `json:"rejected_jobs"`
	MaxJobs        int            `json:"max_jobs"`
	Metrics        *SystemMetrics `json:"metrics,omitempty"`
}

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

type HostResources struct {
	// CPUCores is the CPU this sensor may use: the online CPUs, narrowed by
	// the cgroup's cpuset and CPU quota (cpu.max / cfs_quota_us).
	CPUCores float64 `json:"cpu_cores"`
	// CPUUsedPct is how busy that CPU was since the previous probe, 0-100:
	// the cgroup's usage against its quota when it has one, else the host's.
	CPUUsedPct float64 `json:"cpu_used_pct"`
	// MemTotalBytes is the memory this sensor may use: the host's, or the
	// cgroup's limit when lower.
	MemTotalBytes int64 `json:"mem_total_bytes"`
	// MemAvailableBytes is what is left of it now (page cache that can be
	// reclaimed counts as available).
	MemAvailableBytes int64 `json:"mem_available_bytes"`
	// Load1 is the host's one-minute load average.
	Load1 float64 `json:"load1"`
	// DiskFreeBytes is the space available to the sensor on its work
	// directory's file system.
	DiskFreeBytes int64 `json:"disk_free_bytes"`
}

type JobSample struct {
	Tool    string
	Targets int
	Wall    time.Duration
	// CPUSeconds and PeakRSSBytes come from the job's processes; 0 when
	// unknown (the job ran no measured process).
	CPUSeconds   float64
	PeakRSSBytes int64
	Outcome      Outcome
}

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

type ManagerConfig struct {
	// Cap is the operator's limit on concurrent jobs; 0 sets none (the
	// slots then follow the resources, up to HardMax).
	Cap int
	// HardMax bounds the slots whatever the resources (default
	// DefaultHardMaxSlots).
	HardMax int
	// Tools are the tools the sensor runs; the slots are sized for the most
	// demanding of them. Empty: a generic job (1 core, 512 MiB).
	Tools []string
	// CostHints are the sensor's own per-job cost estimates, the prior of a
	// tool without history (instead of the built-in default); see
	// core.ToolRegistry.CostHints.
	CostHints map[string]ToolCostHint
	// StateFile persists the per-tool cost history ("" keeps it in memory).
	StateFile string
	// Prober reads the resources (nil: the running system, no work dir).
	Prober *Prober
	// ProbeInterval is the longest a probe is reused (default 10s).
	ProbeInterval time.Duration
	// ReservedMemBytes is memory the slots leave free for the sensor itself
	// and the kernel, like a kubelet's system-reserved: what the sensor
	// needs to parse and upload results, heartbeat and poll while its
	// scanners run (api RFC-035 §5.2). 0 is DefaultReservedMem of the
	// memory the sensor may use; negative reserves nothing. CPU is not
	// reserved: it is compressible, and scanners yield it to the sensor
	// (core.ScannerPriority).
	ReservedMemBytes int64
	// OnError receives non-fatal errors (loading or saving the history).
	OnError func(error)
}

type Outcome int

type ProbeResult struct {
	Resources HostResources
	// ThrottledRatio is the share of CPU periods (0-1) in which the cgroup
	// was throttled by its quota since the previous probe.
	ThrottledRatio float64
	// OOMKills is how many processes the cgroup's OOM killer ended since the
	// previous probe.
	OOMKills uint64
}

type Prober struct {
	// Root is prepended to /proc and /sys paths ("" or "/": the real ones).
	Root string
	// WorkDir is the directory whose file system DiskFreeBytes reports
	// ("" skips it).
	WorkDir string
	// NumCPU returns the CPUs the process may run on (default
	// runtime.NumCPU).
	NumCPU func() int
	// DiskFree returns the bytes available on dir's file system (default:
	// statfs; 0 where unsupported).
	DiskFree func(dir string) int64
	// Now is the clock (default time.Now).
	Now func() time.Time
	// contains filtered or unexported fields
}

type SystemMetrics struct {
	CPUPercent    float64   `json:"cpu_percent"`
	MemoryPercent float64   `json:"memory_percent"`
	MemoryUsedMB  int64     `json:"memory_used_mb"`
	MemoryTotalMB int64     `json:"memory_total_mb"`
	NumGoroutines int       `json:"num_goroutines"`
	NumCPU        int       `json:"num_cpu"`
	Timestamp     time.Time `json:"timestamp"`
}

type ToolCostHint struct {
	// Cores is the CPU cores one running job keeps busy.
	Cores float64
	// MemBytes is the peak memory of one job.
	MemBytes int64
	// SecondsPerTarget is the wall time one target takes.
	SecondsPerTarget float64
}

type ToolEstimate struct {
	// CPUSeconds is the CPU time one job uses (all its processes).
	CPUSeconds float64 `json:"est_cpu_s"`
	// MemBytes is the peak resident memory of one job.
	MemBytes int64 `json:"est_mem_bytes"`
	// ThroughputTargetsPerMin is how many targets one job slot scans per
	// minute.
	ThroughputTargetsPerMin float64 `json:"throughput_targets_per_min"`
}