Method process_loop_completed

crates/firewheel-graph/src/processor/profiling.rs:233–309

(&mut self)

    }

    pub fn process_loop_completed(&mut self) {
        let Some(now) = crate::time::now() else {
            return;
        };

        #[cfg(feature = "node_profiling")]
        if self.is_profiling_nodes {
            for (node, &sum) in self
                .heap_data
                .nodes
                .iter_mut()
                .zip(self.heap_data.node_cpu_sums.iter())
            {
                node.cpu_usage = node.cpu_usage.max(sum);
            }
        }

        let overall_cpu_usage = now.duration_since(self.proc_start_instant).as_secs_f64()
            * self.total_cpu_seconds_recip;
        self.overall_cpu_usage = self.overall_cpu_usage.max(overall_cpu_usage);

        if self.is_profiling_bookkeeping {
            let cpu_usage = now
                .duration_since(self.bookkeeping_start_instant)
                .as_secs_f64()
                * self.total_cpu_seconds_recip;
            self.bookkeeping_cpu_usage_sum += cpu_usage;

            self.bookkeeping_cpu_usage = self
                .bookkeeping_cpu_usage
                .max(self.bookkeeping_cpu_usage_sum);
        }

        if self.buffer_tx.consumed() || self.version_counter == 0 {
            {
                let data = self.buffer_tx.input_buffer_mut();

                data.version = self.version_counter;
                data.overall_cpu_usage = self.overall_cpu_usage;

                data.engine_bookkeeping_cpu_usage = self
                    .is_profiling_bookkeeping
                    .then_some(self.bookkeeping_cpu_usage);

                #[cfg(feature = "node_profiling")]
                if self.is_profiling_nodes {
                    if data.nodes.capacity() < self.heap_data.nodes.len()
                        && let Some(new_vec) = self
                            .heap_data
                            .triple_buf_allocations
                            .iter_mut()
                            .find(|v| v.capacity() >= self.heap_data.nodes.len())
                    {
                        core::mem::swap(&mut data.nodes, new_vec);
                    }

                    data.nodes.clear();
                    data.nodes.extend_from_slice(&self.heap_data.nodes);