context

type GangSchedulingContext struct {
	Created                   time.Time
	IsGangJob                 bool
	GangId                    string
	NodeUniformity            string
	PriorityClass             string
	Queue                     string
	JobSchedulingContexts     []*JobSchedulingContext
	TotalResourceRequests     internaltypes.ResourceList
	AllJobsEvicted            bool
	RequestsFloatingResources bool
}

type GangSchedulingFit struct {
	// The number of jobs in the gang that were successfully scheduled.
	NumScheduled int
	// The mean PreemptedAtPriority among successfully scheduled pods in the gang.
	MeanPreemptedAtPriority float64
}

type JobSchedulingContext struct {
	// Time at which this context was created.
	Created time.Time
	// Id of the job this pod corresponds to.
	JobId string
	// Indicates whether this context is for re-scheduling an evicted job.
	IsEvicted bool
	// Job spec.
	Job *jobdb.Job
	// Scheduling requirements of this job.
	// We currently require that each job contains exactly one pod spec.
	PodRequirements *internaltypes.PodRequirements
	// Resource requirements in an efficient internaltypes.ResourceList
	KubernetesResourceRequirements internaltypes.ResourceList
	// Node selectors to consider in addition to those included with the PodRequirements.
	// These are added as part of scheduling to further constrain where nodes are scheduled,
	// e.g., to ensure evicted jobs are re-scheduled onto the same node.
	//
	// If some key appears in both PodRequirements.NodeSelector and AdditionalNodeSelectors,
	// the value in AdditionalNodeSelectors trumps that of PodRequirements.NodeSelector.
	AdditionalNodeSelectors map[string]string
	// Tolerations to consider in addition to those included with the PodRequirements.
	// These are added as part of scheduling to expand the set of nodes a job can be scheduled on.
	AdditionalTolerations []v1.Toleration
	// Reason for why the job could not be scheduled.
	// Empty if the job was scheduled successfully.
	UnschedulableReason string
	// Pod scheduling contexts for the individual pods that make up the job.
	PodSchedulingContext *PodSchedulingContext
	// The number of active jobs in the gang this jctx belongs to
	// This may differ from the jobs GangInfo cardinality, as it finished jobs are not included in this count
	CurrentGangCardinality int
	// This is the node the pod is assigned to.
	// This is only set for evicted jobs and is set alongside adding an additionalNodeSelector for the node
	AssignedNode *internaltypes.Node
	// job that preempted this pod
	PreemptingJob *jobdb.Job
	// The type of preemption used to preempt this job (i.e fairshare, urgency)
	PreemptionType PreemptionType
	// Description of the cause of preemption
	PreemptionDescription string
	// If this job context should contribute to the billable resource of the queue
	Billable bool
	// Gang node uniformity label name (e.g., "rack") - only set for gang jobs with uniformity requirements
	GangNodeUniformityLabelName string
	// Gang node uniformity label value (e.g., "rack-1") - the actual value selected during scheduling
	GangNodeUniformityLabelValue string
}

type PodSchedulingContext struct {
	// Time at which this context was created.
	Created time.Time
	// ID of the node that the pod was assigned to, or empty.
	NodeId string
	// If set, indicates that the pod was scheduled on a specific node type.
	WellKnownNodeTypeName string
	// Priority this pod was most recently attempted to be scheduled at.
	// If scheduling was successful, resources were marked as allocated to the job at this priority.
	ScheduledAtPriority int32
	// Maximum priority that this pod preempted other pods at.
	PreemptedAtPriority int32
	// Total number of nodes in the cluster when trying to schedule.
	NumNodes int
	// Number of nodes excluded by reason.
	NumExcludedNodesByReason map[string]int
	// If this pod was scheduled as an away job
	ScheduledAway bool
	// The method of scheduling that was used to schedule this job
	SchedulingMethod SchedulingType
}

type PreemptionType string

type QueueSchedulingContext struct {
	// The scheduling context to which this QueueSchedulingContext belongs.
	SchedulingContext *SchedulingContext
	// Time at which this context was created.
	Created time.Time
	// Queue name.
	Queue string
	// Determines the fair share of this queue relative to other queues.
	Weight float64
	// Raw Weight of the queue before any priority boosts.
	// This is purely informational as all scheduling decisions are made using Weight
	RawWeight float64
	// Limits job scheduling rate for this queue.
	// Use the "Started" time to ensure limiter state remains constant within each scheduling round.
	Limiter *rate.Limiter
	// Total resources assigned to the queue across all clusters by priority class priority.
	// Includes jobs scheduled during this invocation of the scheduler.
	Allocated internaltypes.ResourceList
	// Resource which should be charged for when using market driven scheduling
	BillableResource internaltypes.ResourceList
	// Used to penalize short jobs by pretending they are still running
	// if they started recently but then exited.
	ShortJobPenalty internaltypes.ResourceList
	// Total demand from this queue.  This is essentially the cumulative resources of all non-terminal jobs at the
	// start of the scheduling cycle
	Demand internaltypes.ResourceList
	// Constrained demand for this queue. This differs from Demand in that it takes into account any constraints that we have
	// placed on the queue
	ConstrainedDemand internaltypes.ResourceList
	// Fair share is the weight of this queue over the sum of the weights of all queues
	FairShare float64
	// UncappedAdjustedFairShare includes not only this queue's fairshare, but also this queue's share of any unused fairshare from other queues. It's
	// not capped by this queue's demand, so includes any fairshare unused by this queue. It's effectively the share this queue would get if it had infinite demand.
	// This measure is designed to not punish queues for being undemanding.
	UncappedAdjustedFairShare float64
	// DemandCappedAdjustedFairShare includes not only this queue's fairshare, but also this queue's share of any unused fairshare from other queues. It's
	// capped by this queue's demand, so does not include any fairshare unused by this queue.
	DemandCappedAdjustedFairShare float64
	// IdealisedValue is the total value of jobs that would be scheduled from this queue if there was no fragmentation.
	// This only applies if the pool was market priced
	IdealisedValue float64
	// IdealisedAllocated are the resources that would be allocated from this queue if there was no fragmentation.
	// This only applies if the pool was market priced
	IdealisedAllocated internaltypes.ResourceList
	// RealisedValue is the total value of jobs that were actually scheduled.  Note that this us only populated
	// on market driven pools
	RealisedValue float64
	// Total resources assigned to the queue across all clusters by priority class.
	// Includes jobs scheduled during this invocation of the scheduler.
	AllocatedByPriorityClass map[string]internaltypes.ResourceList
	// Resources assigned to this queue during this scheduling cycle.
	ScheduledResourcesByPriorityClass map[string]internaltypes.ResourceList
	// Resources evicted from this queue during this scheduling cycle.
	EvictedResourcesByPriorityClass map[string]internaltypes.ResourceList
	// Resources preempted from this queue during this scheduling cycle.
	PreemptedByOptimiserResourceByPriorityClass map[string]internaltypes.ResourceList
	// Job scheduling contexts associated with successful scheduling attempts.
	SuccessfulJobSchedulingContexts map[string]*JobSchedulingContext
	// Job scheduling contexts associated with rescheduled jobs.
	RescheduledJobSchedulingContexts map[string]*JobSchedulingContext
	// Job scheduling contexts associated with preempted jobs.
	PreemptedByOptimiserJobSchedulingContexts map[string]*JobSchedulingContext
	// Job scheduling contexts associated with unsuccessful scheduling attempts.
	UnsuccessfulJobSchedulingContexts map[string]*JobSchedulingContext
	// Jobs evicted in this round.
	EvictedJobsById map[string]bool
}

type SchedulingContext struct {
	// Time at which the scheduling cycle started.
	Started time.Time
	// Time at which the scheduling cycle finished.
	Finished time.Time
	// Pool for which we're currently scheduling jobs.
	Pool string
	// Determines how fairness is computed.
	FairnessCostProvider fairness.FairnessCostProvider
	// Limits job scheduling rate globally across all queues.
	// Use the "Started" time to ensure limiter state remains constant within each scheduling round.
	Limiter *rate.Limiter
	// Sum of queue weights across all queues.
	WeightSum float64
	// Per-queue scheduling contexts.
	QueueSchedulingContexts map[string]*QueueSchedulingContext
	// Total resources across all clusters in this pool available at the start of the scheduling cycle.
	TotalResources internaltypes.ResourceList
	// Allocated resources across all clusters in this pool
	Allocated internaltypes.ResourceList
	// Resources assigned across all queues during this scheduling cycle.
	ScheduledResources internaltypes.ResourceList
	// Resources evicted across all queues during this scheduling cycle.
	EvictedResources internaltypes.ResourceList
	// Total number of successfully scheduled jobs.
	NumScheduledJobs int
	// Total number of successfully scheduled gangs.
	NumScheduledGangs int
	// Total number of evicted jobs.
	NumEvictedJobs int
	// TODO(reports): Count the number of evicted gangs.
	// Reason for why the scheduling round finished.
	TerminationReason string
	// Used to efficiently generate scheduling keys.
	SchedulingKeyGenerator *internaltypes.SchedulingKeyGenerator
	// Record of job scheduling requirements known to be unfeasible.
	// Used to immediately reject new jobs with identical reqirements.
	// Maps to the JobSchedulingContext of a previous job attempted to schedule with the same key.
	UnfeasibleSchedulingKeys     map[internaltypes.SchedulingKey]*JobSchedulingContext
	ExperimentalIndicativeShares map[int]float64
	SpotPrice                    *float64
}

type SchedulingType string