initialsizeclass

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

type Analyzer interface {
	// Analyze an REv2 Action. This operation should be called
	// without holding any locks, as it may block.
	//
	// All methods called against the Selector that is returned and
	// any Learners yielded from it should be called while holding a
	// global lock.
	Analyze(ctx context.Context, digestFunction digest.Function, action *remoteexecution.Action) (Selector, error)
}

type Learner interface {
	// The action completed successfully. The execution time is
	// provided.
	//
	// If this method returns a nil Learner, the scheduler can
	// finalize the operation entirely. If this method returns a new
	// Learner, the scheduler is requested to run the action another
	// time in the background, just for learning purposes. It is
	// valid for the scheduler to already communicate completion to
	// the client. The scheduler may limit the amount of work it's
	// willing to run in the background.
	Succeeded(duration time.Duration, sizeClasses []uint32) (sizeClass int, expectedDuration, timeout time.Duration, learner Learner)

	// The action completed with a failure.
	//
	// If this method returns a nil Learner, the execution failure
	// is definitive and should be propagated to the client. If this
	// method returns a new Learner, execution must be retried on
	// the largest size class, using the timeout that is returned.
	Failed(timedOut bool) (expectedDuration, timeout time.Duration, learner Learner)

	// Clients have abandoned the action, meaning that execution of
	// the action was terminated. Nothing may be learned from this
	// action.
	Abandoned()
}

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

type PreviousExecutionStatsHandle re_blobstore.MutableProtoHandle[*iscc.PreviousExecutionStats]

type PreviousExecutionStatsStore re_blobstore.MutableProtoStore[*iscc.PreviousExecutionStats]

type Selector interface {
	// Given a list of size classes that are currently present,
	// select a size class on which the action needs to be
	// scheduled.
	//
	// The Selector can override the timeout of the action. When
	// attempting to run an action on a smaller size class, it may
	// be desirable to put a timeout in place that is based on
	// previous execution times observed on larger size classes.
	// This ensures that the system remains responsive, even in the
	// case of mispredictions.
	//
	// A Learner is returned that the scheduler must use to
	// communicate the outcome of the execution, so that future
	// executions have a lower probability of making mispredictions.
	Select(sizeClasses []uint32) (sizeClass int, expectedDuration, timeout time.Duration, learner Learner)

	// Clients have abandoned the action, meaning that no size class
	// selection decision needs to be made. This may, for example,
	// happen if the action is deduplicated against one that is
	// already running.
	Abandoned()
}

type Strategy struct {
	// Probability between [0.0, 1.0] at which this strategy should
	// be chosen. The sum of all probabilities returned by
	// GetStrategies() should at most be 1.0. If the sum of all
	// probabilities is less than 1.0, the remainder should be the
	// probability of running the action on the largest size class.
	Probability float64
	// Whether the action has a high probability of failing. In that
	// case it is preferable to run the action on the largest size
	// class immediately, only running it on the smaller size class
	// in the background afterwards.
	RunInBackground bool
	// The execution timeout to use when running this action in the
	// foreground on this size class. For the largest size class,
	// the original timeout value should be used.
	//
	// To obtain the execution timeout when running this action in
	// the background, a separate call to
	// GetBackgroundExecutionTimeout() needs to be made. This
	// ensures that the latest obtained execution time of the
	// foreground execution on the largest size class is taken into
	// account when computing the timeout for the smaller size
	// class.
	ForegroundExecutionTimeout time.Duration
}

type StrategyCalculator interface {
	GetStrategies(perSizeClassStatsMap map[uint32]*iscc.PerSizeClassStats, sizeClasses []uint32, originalTimeout time.Duration) []Strategy
	GetBackgroundExecutionTimeout(perSizeClassStatsMap map[uint32]*iscc.PerSizeClassStats, sizeClasses []uint32, sizeClassIndex int, originalTimeout time.Duration) time.Duration
}