Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_retries: u32,
}

What a failed trial is allowed to cost before the study gives up on it.

RL objectives crash: a CUDA OOM, a NaN, a flaky simulator. Re-running the same parameters is usually the right answer and is a policy, not a sampler concern.

A retry is a new trial: it gets its own number, its own record and its own slot against Budget::max_trials, and its parameters are pinned by a TrialTemplate taken from the failed trial’s record. Anything the objective suggests that the failed run never reached is therefore sampled afresh, under the new trial’s seed.

Determinism: a retrying study is replayable, not pre-determined

Trial-number-indexed determinism holds for a stateless sampler with an empty template queue. A non-zero retry policy empties that precondition: the failed configuration is pushed onto the queue at the moment the failure is observed, and under parallelism(n) with n > 1 that moment is thread-scheduling dependent — so the retry template lands on whichever trial number the next ask happens to claim. Two runs of the same seed then agree on the multiset of configurations they retry, but not necessarily on which trial number carries which. Sequentially the mapping is fixed and reproducible.

This is not fixable by locking: the enqueue time is itself order-dependent, so a study with retries is replayable (its recorded history explains itself completely) rather than pre-determined (computable from the seed before it runs). Use parallelism(1) when the number-to-configuration map itself has to be reproducible.

use atune_core::study::RetryPolicy;

assert_eq!(RetryPolicy::default(), RetryPolicy::none());
assert_eq!(RetryPolicy::times(2).max_retries, 2);

Fields

max_retries: u32

How many additional attempts a failed configuration gets. 0 disables retrying.

Implementations

impl RetryPolicy

pub const fn none() -> Self

No retries: a failed trial stays failed.

pub const fn times(max_retries: u32) -> Self

Re-enqueue a failed configuration up to max_retries times.

Trait Implementations

impl Clone for RetryPolicy

fn clone(&self) -> RetryPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RetryPolicy

impl Debug for RetryPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RetryPolicy

fn default() -> RetryPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RetryPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RetryPolicy

impl PartialEq for RetryPolicy

fn eq(&self, other: &RetryPolicy) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RetryPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RetryPolicy