pub trait Checkpoint<S, I> {
    fn save(&self, solver: &S, state: &I) -> Result<(), Error>;
    fn load(&self) -> Result<Option<(S, I)>, Error>;
    fn frequency(&self) -> CheckpointingFrequency;

    fn save_cond(&self, solver: &S, state: &I, iter: u64) -> Result<(), Error> { ... }
Expand description

An interface for checkpointing methods

Handles saving of a checkpoint. The methods save (saving the checkpoint), load (loading a checkpoint) are mandatory to implement. The method save_cond determines if the conditions for calling save are met, and if yes, calles save. freqency returns the conditions in form of a CheckpointingFrequency.


use argmin::core::Error;
use argmin::core::checkpointing::{Checkpoint, CheckpointingFrequency};
use serde::{Serialize, de::DeserializeOwned};

struct MyCheckpoint {
   frequency: CheckpointingFrequency,
   // ..

impl<S, I> Checkpoint<S, I> for MyCheckpoint
    // Both `solver` (`S`) and `state` (`I`) (probably) need to be (de)serializable
    S: Serialize + DeserializeOwned,
    I: Serialize + DeserializeOwned,
    fn save(&self, solver: &S, state: &I) -> Result<(), Error> {
        // Save `solver` and `state`

    fn load(&self) -> Result<Option<(S, I)>, Error> {
        // Load `solver` and `state` from checkpoint
        // Return `Ok(None)` in case checkpoint is not found.
        Ok(Some((solver, state)))

    fn frequency(&self) -> CheckpointingFrequency {

Required Methods

Save a checkpoint

Gets a reference to the current solver of type S and to the current state of type I. Both solver and state can maintain state. Optimization problems itself are not allowed to have state which changes during an optimization (at least not in the context of checkpointing).

Loads a saved checkpoint

Returns the solver of type S and the state of type I.

Indicates how often checkpoints should be saved

Returns enum CheckpointingFrequency.

Provided Methods

Saves a checkpoint when the checkpointing condition is met.

Calls save in each iteration (CheckpointingFrequency::Always), every X iterations (CheckpointingFrequency::Every(X)) or never (CheckpointingFrequency::Never).