eryon_rt/types/

statistics.rs

/*
    Appellation: statistics <module>
    Contrib: @FL03
*/

/// Statistics about runtime resource utilization
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(
    feature = "serde",
    derive(serde_derive::Deserialize, serde_derive::Serialize),
    serde(rename_all = "snake_case")
)]
pub struct RuntimeStats {
    /// Total number of nodes in the fragment
    pub(crate) node_count: usize,
    /// Number of currently active nodes
    pub(crate) active_node_count: usize,
    /// Number of worker threads available
    pub(crate) worker_count: usize,
    /// Number of queued tasks
    pub(crate) queued_task_count: usize,
    /// Number of active tasks
    pub(crate) active_task_count: usize,
}

/// Statistics about task execution
#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
#[cfg_attr(
    feature = "serde",
    derive(serde_derive::Deserialize, serde_derive::Serialize),
    serde(rename_all = "snake_case")
)]
pub struct ExecutionStats {
    /// Total tasks completed
    pub(crate) completed_tasks: usize,
    /// Total tasks that failed
    pub(crate) failed_tasks: usize,
    /// Average execution time in milliseconds
    pub(crate) avg_execution_time_ms: f32,
    /// Number of tasks currently running
    pub(crate) active_tasks: usize,
}

impl ExecutionStats {
    /// Create a new execution stats object
    pub fn new() -> Self {
        ExecutionStats::default()
    }
    /// returns a mutable reference to the active tasks
    pub const fn active_tasks_mut(&mut self) -> &mut usize {
        &mut self.active_tasks
    }
    /// return a copy of the average execution time in milliseconds
    pub const fn avg_execution_time_ms(&self) -> f32 {
        self.avg_execution_time_ms
    }
    /// returns a mutable reference to the average execution time in milliseconds
    pub const fn avg_execution_time_ms_mut(&mut self) -> &mut f32 {
        &mut self.avg_execution_time_ms
    }
    /// return a copy of the completed tasks
    pub const fn completed_tasks(&self) -> usize {
        self.completed_tasks
    }
    /// returns a mutable reference to the completed tasks
    pub const fn completed_tasks_mut(&mut self) -> &mut usize {
        &mut self.completed_tasks
    }
    /// return a copy of the failed tasks
    pub const fn failed_tasks(&self) -> usize {
        self.failed_tasks
    }
    /// returns a mutable reference to the failed tasks
    pub const fn failed_tasks_mut(&mut self) -> &mut usize {
        &mut self.failed_tasks
    }
    /// return a copy of the active tasks
    pub const fn active_tasks(&self) -> usize {
        self.active_tasks
    }
    /// updates the current active tasks and returns a mutable reference to the current
    /// instance
    pub fn set_active_tasks(&mut self, active_tasks: usize) -> &mut Self {
        self.active_tasks = active_tasks;
        self
    }
    /// updates the current average execution time in milliseconds and returns a mutable reference
    pub fn set_avg_execution_time_ms(&mut self, avg_execution_time_ms: f32) -> &mut Self {
        self.avg_execution_time_ms = avg_execution_time_ms;
        self
    }
    /// updates the current completed tasks and returns a mutable reference to the current instance
    pub fn set_completed_tasks(&mut self, completed_tasks: usize) -> &mut Self {
        self.completed_tasks = completed_tasks;
        self
    }
    /// updates the current failed tasks and returns a mutable reference to the current instance
    pub fn set_failed_tasks(&mut self, failed_tasks: usize) -> &mut Self {
        self.failed_tasks = failed_tasks;
        self
    }
    /// consumes the current instance to create another with the given active tasks
    pub fn with_active_tasks(self, active_tasks: usize) -> Self {
        Self {
            active_tasks,
            ..self
        }
    }
    /// consumes the current instance to create another with the given average execution time in milliseconds
    pub fn with_avg_execution_time_ms(self, avg_execution_time_ms: f32) -> Self {
        Self {
            avg_execution_time_ms,
            ..self
        }
    }
    /// consumes the current instance to create another with the given completed tasks
    pub fn with_completed_tasks(self, completed_tasks: usize) -> Self {
        Self {
            completed_tasks,
            ..self
        }
    }
    /// consumes the current instance to create another with the given failed tasks
    pub fn with_failed_tasks(self, failed_tasks: usize) -> Self {
        Self {
            failed_tasks,
            ..self
        }
    }
}

impl RuntimeStats {
    /// Create a new runtime stats object
    pub fn new() -> Self {
        RuntimeStats::default()
    }
    /// return a copy of the active node count
    pub const fn active_node_count(&self) -> usize {
        self.active_node_count
    }
    /// returns a mutable reference to the active node count
    pub const fn active_node_count_mut(&mut self) -> &mut usize {
        &mut self.active_node_count
    }
    /// return a copy of the active task count
    pub const fn active_task_count(&self) -> usize {
        self.active_task_count
    }
    /// returns a mutable reference to the active task count
    pub const fn active_task_count_mut(&mut self) -> &mut usize {
        &mut self.active_task_count
    }
    /// return a copy of the node count
    pub const fn node_count(&self) -> usize {
        self.node_count
    }
    /// returns a mutable reference to the node count
    pub const fn node_count_mut(&mut self) -> &mut usize {
        &mut self.node_count
    }
    /// return a copy of the queued task count
    pub const fn queued_task_count(&self) -> usize {
        self.queued_task_count
    }
    /// returns a mutable reference to the queued task count
    pub const fn queued_task_count_mut(&mut self) -> &mut usize {
        &mut self.queued_task_count
    }
    /// return a copy of the worker count
    pub const fn worker_count(&self) -> usize {
        self.worker_count
    }
    /// returns a mutable reference to the worker count
    pub const fn worker_count_mut(&mut self) -> &mut usize {
        &mut self.worker_count
    }
    /// updates the current active node count and returns a mutable reference to the current
    ///  instance
    pub fn set_active_node_count(&mut self, active_node_count: usize) -> &mut Self {
        self.active_node_count = active_node_count;
        self
    }
    /// updates the current active task count and returns a mutable reference to the current
    /// instance
    pub fn set_active_task_count(&mut self, active_task_count: usize) -> &mut Self {
        self.active_task_count = active_task_count;
        self
    }
    /// updates the current node count and returns a mutable reference to the current instance
    pub fn set_node_count(&mut self, node_count: usize) -> &mut Self {
        self.node_count = node_count;
        self
    }
    /// updates the current queued task count and returns a mutable reference to the current
    /// instance
    pub fn set_queued_task_count(&mut self, queued_task_count: usize) -> &mut Self {
        self.queued_task_count = queued_task_count;
        self
    }
    /// updates the current worker count and returns a mutable reference to the current instance
    pub fn set_worker_count(&mut self, worker_count: usize) -> &mut Self {
        self.worker_count = worker_count;
        self
    }

    // "with_" methods (alphabetically ordered)
    /// consumes the current instance to create another with the given active node count
    pub fn with_active_node_count(self, active_node_count: usize) -> Self {
        Self {
            active_node_count,
            ..self
        }
    }
    /// consumes the current instance to create another with the given active task count
    pub fn with_active_task_count(self, active_task_count: usize) -> Self {
        Self {
            active_task_count,
            ..self
        }
    }
    /// consumes the current instance to create another with the given node count
    pub fn with_node_count(self, node_count: usize) -> Self {
        Self { node_count, ..self }
    }
    /// consumes the current instance to create another with the given queued task count
    pub fn with_queued_task_count(self, queued_task_count: usize) -> Self {
        Self {
            queued_task_count,
            ..self
        }
    }
    /// consumes the current instance to create another with the given worker count
    pub fn with_worker_count(self, worker_count: usize) -> Self {
        Self {
            worker_count,
            ..self
        }
    }
}