Struct CpuUsage 

pub struct CpuUsage { /* private fields */ }

A reading of the CPU monitoring counters.

percentage is the figure to look at; the rest describes the acquisition cycle it came from and how far along the next one is.

Implementations

impl CpuUsage

pub const fn percentage(&self) -> f32

Percentage of the measured period spent busy, averaged over the last completed acquisition cycle.

Zero until the first cycle completes, which takes measurements_per_cycle tics — for the audio thread, that many blocks.

Examples found in repository

examples/cpu.rs (line 237)

    fn render_post(&mut self, states: &mut [Bank], context: &mut BlockContext) {
        #[allow(
            clippy::cast_precision_loss,
            reason = "a block's frame count is far below f32's exact integer range"
        )]
        let frames = context.audio_frames() as f32;
        for (phase, increment) in self.phases.iter_mut().zip(&self.phase_increments) {
            *phase = (*phase + frames * increment) % TAU;
        }

        self.blocks += 1;
        if self.blocks % self.blocks_per_report != 0 {
            return;
        }
        // Read here, on the main audio thread, and handed to the task
        // as plain numbers.
        let thread = context.cpu_usage().map_or(0.0, |usage| usage.percentage());
        let section = states
            .first()
            .map_or(0.0, |bank| bank.timer.usage().percentage());
        self.published
            .thread
            .store(thread.to_bits(), Ordering::Relaxed);
        self.published
            .section
            .store(section.to_bits(), Ordering::Relaxed);
        if let Some(task) = &self.task {
            task.schedule(context);
        }
    }

examples/parallel.rs (line 320)

    fn cleanup(&mut self, states: &mut [Voice], context: &CleanupContext) {
        let mut rendered = 0;
        for state in states.iter() {
            rt_println!(
                "parallel: thread={} tid={} cpu={} range={}..{} calls={} frames={} section={:.1}%",
                state.thread,
                state.thread_id,
                state.cpu,
                state.first_frame,
                state.last_frame,
                state.calls,
                state.frames,
                state.timer.usage().percentage()
            );
            rendered += state.frames;
        }
        let frames = context.audio_frames() as u64;
        let expected = self.started * frames;
        rt_println!(
            "parallel: blocks={} frames={frames} rendered={rendered} expected={expected}",
            self.started
        );
        rt_println!(
            "parallel: uncovered={} abandoned={} unfinished={}",
            self.uncovered,
            self.abandoned,
            self.started - self.finished
        );
        let busy = context.cpu_usage().map_or(0.0, |usage| usage.percentage());
        rt_println!("parallel: audio-thread={busy:.1}%");
    }

pub const fn busy(&self) -> Duration

Busy time accumulated so far in the current, incomplete cycle.

pub const fn total(&self) -> Duration

Total time accumulated so far in the current, incomplete cycle — busy and idle together.

pub const fn measurements_per_cycle(&self) -> u32

How many tics make up an acquisition cycle (Bela’s count).

pub const fn measurements_taken(&self) -> u32

How many tics have happened in the current cycle (Bela’s currentCount).

Trait Implementations

impl Clone for CpuUsage

fn clone(&self) -> CpuUsage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CpuUsage

impl Debug for CpuUsage

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

Formats the value using the given formatter.

impl Display for CpuUsage

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

Formats as 12.3% busy, averaged over 1000 measurements.

impl PartialEq for CpuUsage

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CpuUsage