cu-profiler-core 0.2.0

Core domain model, log parser, budget engine and diagnostics for cu-profiler
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

//! Execution backends.
//!
//! A backend turns a [`Scenario`] into raw logs. v1 ships a fully-working
//! [`RecordedLogsBackend`] (deterministic, used for tests, fixtures and the
//! `inspect` command) and *skeleton* live backends whose interfaces are defined
//! but which return [`crate::Error::BackendUnimplemented`] until wired to
//! `solana-program-test` / `BanksClient`.

mod banks_client;
mod program_test;
mod recorded;

pub use banks_client::BanksClientBackend;
pub use program_test::ProgramTestBackend;
pub use recorded::RecordedLogsBackend;

use crate::Result;
use crate::metadata::BackendKind;
use crate::scenario::Scenario;

/// The raw result of executing a scenario.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SimulationOutput {
    /// Program logs, one entry per line.
    pub logs: Vec<String>,
    /// Whether the transaction succeeded.
    pub success: bool,
}

impl SimulationOutput {
    /// A successful output from the given logs.
    #[must_use]
    pub fn success(logs: Vec<String>) -> Self {
        Self {
            logs,
            success: true,
        }
    }
}

/// Anything that can execute a scenario and return logs.
pub trait ExecutionBackend {
    /// Which kind of backend this is (recorded in report metadata).
    fn kind(&self) -> BackendKind;

    /// Execute `scenario`, returning its raw logs.
    ///
    /// # Errors
    /// Returns [`crate::Error::Simulation`] on execution failure, or
    /// [`crate::Error::BackendUnimplemented`] for skeleton backends.
    fn run(&self, scenario: &Scenario) -> Result<SimulationOutput>;

    /// Whether re-running the same scenario always yields identical logs.
    ///
    /// Deterministic backends (e.g. recorded-log replay) gain nothing from
    /// multi-sampling — `Scenario::samples` is ignored for them, so the profiler
    /// never reports fabricated run-to-run variance. Live execution backends that
    /// can vary between runs override this to `false` (the default) so sampling
    /// applies. See [`crate::profiler::Profiler::run`].
    fn is_deterministic(&self) -> bool {
        false
    }
}