optimizer 1.0.1

Bayesian and population-based optimization library with an Optuna-like API for hyperparameter tuning and black-box optimization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! In-memory storage backend.
//!
//! [`MemoryStorage`] is the default backend used by every
//! [`Study`](crate::Study).  Trials are stored in a
//! `Vec<CompletedTrial<V>>` behind a [`parking_lot::RwLock`] for
//! thread-safe access.
//!
//! # When to use
//!
//! - **Single-process** studies where persistence is not needed.
//! - **Testing** or **prototyping** — zero configuration required.
//! - When you want the **fastest** possible read/write performance
//!   (no disk I/O).
//!
//! For persistent storage that survives process restarts, see
//! `JournalStorage` (requires the `journal` feature).
//!
//! # Example
//!
//! ```
//! use optimizer::prelude::*;
//! use optimizer::storage::MemoryStorage;
//!
//! // Explicit memory storage (equivalent to the default)
//! let storage = MemoryStorage::<f64>::new();
//! let study = Study::builder().minimize().storage(storage).build();
//! ```

use core::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;

use parking_lot::RwLock;

use super::Storage;
use crate::sampler::CompletedTrial;

/// In-memory trial storage (the default).
///
/// Wrap a `Vec<CompletedTrial<V>>` behind a read-write lock so that
/// trials can be appended from any thread.  This is the backend that
/// [`Study`](crate::Study) uses when no explicit storage is provided.
///
/// Use [`with_trials`](Self::with_trials) to seed a study with
/// previously collected data.
///
/// # Example
///
/// ```
/// use optimizer::storage::{MemoryStorage, Storage};
///
/// let storage = MemoryStorage::<f64>::new();
/// assert_eq!(storage.trials_arc().read().len(), 0);
/// ```
pub struct MemoryStorage<V> {
    trials: Arc<RwLock<Vec<CompletedTrial<V>>>>,
    next_id: AtomicU64,
}

impl<V> MemoryStorage<V> {
    /// Create a new, empty in-memory store.
    #[must_use]
    pub fn new() -> Self {
        Self {
            trials: Arc::new(RwLock::new(Vec::new())),
            next_id: AtomicU64::new(0),
        }
    }

    /// Create an in-memory store pre-populated with `trials`.
    ///
    /// The internal ID counter is set to one past the highest trial ID
    /// so that subsequent trials receive unique IDs.
    #[must_use]
    pub fn with_trials(trials: Vec<CompletedTrial<V>>) -> Self {
        let next_id = trials.iter().map(|t| t.id).max().map_or(0, |id| id + 1);
        Self {
            trials: Arc::new(RwLock::new(trials)),
            next_id: AtomicU64::new(next_id),
        }
    }

    /// Ensure the ID counter is at least `min_value`.
    #[cfg(feature = "journal")]
    pub(crate) fn bump_next_id(&self, min_value: u64) {
        self.next_id.fetch_max(min_value, Ordering::SeqCst);
    }
}

impl<V> Default for MemoryStorage<V> {
    fn default() -> Self {
        Self::new()
    }
}

impl<V: Send + Sync> Storage<V> for MemoryStorage<V> {
    fn push(&self, trial: CompletedTrial<V>) {
        self.trials.write().push(trial);
    }

    fn trials_arc(&self) -> &Arc<RwLock<Vec<CompletedTrial<V>>>> {
        &self.trials
    }

    fn next_trial_id(&self) -> u64 {
        self.next_id.fetch_add(1, Ordering::SeqCst)
    }

    fn peek_next_trial_id(&self) -> u64 {
        self.next_id.load(Ordering::SeqCst)
    }
}