This commit is contained in:
1 parent
f29712d158
commit
3e053a81ab
123 files changed
+31930
-1404
No files matched your search
+81
@@ -0,0 +1,81 @@
|
||||
use core::{any::type_name, marker::PhantomData};
|
||||
|
||||
use bevy_app::{Plugin, PreUpdate};
|
||||
use bevy_diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic};
|
||||
use bevy_ecs::{resource::Resource, system::Res};
|
||||
use bevy_platform::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use crate::{
|
||||
erased_render_asset::{ErasedRenderAsset, ErasedRenderAssets},
|
||||
Extract, ExtractSchedule, RenderApp,
|
||||
};
|
||||
|
||||
/// Collects diagnostics for a [`ErasedRenderAsset`].
|
||||
///
|
||||
/// If the [`ErasedRenderAsset::ErasedAsset`] is shared between other
|
||||
/// [`ErasedRenderAsset`], they all will report the same number.
|
||||
pub struct ErasedRenderAssetDiagnosticPlugin<A: ErasedRenderAsset> {
|
||||
suffix: &'static str,
|
||||
_phantom: PhantomData<A>,
|
||||
}
|
||||
|
||||
impl<A: ErasedRenderAsset> ErasedRenderAssetDiagnosticPlugin<A> {
|
||||
pub fn new(suffix: &'static str) -> Self {
|
||||
Self {
|
||||
suffix,
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render_asset_diagnostic_path() -> DiagnosticPath {
|
||||
DiagnosticPath::from_components(["erased_render_asset", type_name::<A>()])
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: ErasedRenderAsset> Plugin for ErasedRenderAssetDiagnosticPlugin<A> {
|
||||
fn build(&self, app: &mut bevy_app::App) {
|
||||
app.register_diagnostic(
|
||||
Diagnostic::new(Self::render_asset_diagnostic_path()).with_suffix(self.suffix),
|
||||
)
|
||||
.init_resource::<ErasedRenderAssetMeasurements<A>>()
|
||||
.add_systems(PreUpdate, add_erased_render_asset_measurement::<A>);
|
||||
|
||||
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
|
||||
render_app.add_systems(ExtractSchedule, measure_erased_render_asset::<A>);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Resource)]
|
||||
struct ErasedRenderAssetMeasurements<A: ErasedRenderAsset> {
|
||||
assets: AtomicUsize,
|
||||
_phantom: PhantomData<A>,
|
||||
}
|
||||
|
||||
impl<A: ErasedRenderAsset> Default for ErasedRenderAssetMeasurements<A> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
assets: AtomicUsize::default(),
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn add_erased_render_asset_measurement<A: ErasedRenderAsset>(
|
||||
mut diagnostics: Diagnostics,
|
||||
measurements: Res<ErasedRenderAssetMeasurements<A>>,
|
||||
) {
|
||||
diagnostics.add_measurement(
|
||||
&ErasedRenderAssetDiagnosticPlugin::<A>::render_asset_diagnostic_path(),
|
||||
|| measurements.assets.load(Ordering::Relaxed) as f64,
|
||||
);
|
||||
}
|
||||
|
||||
fn measure_erased_render_asset<A: ErasedRenderAsset>(
|
||||
measurements: Extract<Res<ErasedRenderAssetMeasurements<A>>>,
|
||||
assets: Res<ErasedRenderAssets<A::ErasedAsset>>,
|
||||
) {
|
||||
measurements
|
||||
.assets
|
||||
.store(assets.iter().count(), Ordering::Relaxed);
|
||||
}
|
||||
+711
@@ -0,0 +1,711 @@
|
||||
use alloc::{borrow::Cow, sync::Arc};
|
||||
use core::{
|
||||
ops::{DerefMut, Range},
|
||||
sync::atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
use std::thread::{self, ThreadId};
|
||||
|
||||
use bevy_diagnostic::{Diagnostic, DiagnosticMeasurement, DiagnosticPath, DiagnosticsStore};
|
||||
use bevy_ecs::resource::Resource;
|
||||
use bevy_ecs::system::{Res, ResMut};
|
||||
use bevy_platform::time::Instant;
|
||||
use std::sync::Mutex;
|
||||
use wgpu::{
|
||||
Buffer, BufferDescriptor, BufferUsages, CommandEncoder, ComputePass, Features, MapMode,
|
||||
PipelineStatisticsTypes, QuerySet, QuerySetDescriptor, QueryType, RenderPass,
|
||||
};
|
||||
|
||||
use crate::renderer::{RenderAdapterInfo, RenderDevice, RenderQueue, WgpuWrapper};
|
||||
|
||||
use super::RecordDiagnostics;
|
||||
|
||||
// buffer offset must be divisible by 256, so this constant must be divisible by 32 (=256/8)
|
||||
const MAX_TIMESTAMP_QUERIES: u32 = 256;
|
||||
const MAX_PIPELINE_STATISTICS: u32 = 128;
|
||||
|
||||
const TIMESTAMP_SIZE: u64 = 8;
|
||||
const PIPELINE_STATISTICS_SIZE: u64 = 40;
|
||||
|
||||
struct DiagnosticsRecorderInternal {
|
||||
timestamp_period_ns: f32,
|
||||
features: Features,
|
||||
current_frame: Mutex<FrameData>,
|
||||
submitted_frames: Vec<FrameData>,
|
||||
finished_frames: Vec<FrameData>,
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context: tracy_client::GpuContext,
|
||||
}
|
||||
|
||||
/// Records diagnostics into [`QuerySet`]'s keeping track of the mapping between
|
||||
/// spans and indices to the corresponding entries in the [`QuerySet`].
|
||||
#[derive(Resource)]
|
||||
pub struct DiagnosticsRecorder(WgpuWrapper<DiagnosticsRecorderInternal>);
|
||||
|
||||
impl DiagnosticsRecorder {
|
||||
/// Creates the new `DiagnosticsRecorder`.
|
||||
pub fn new(
|
||||
adapter_info: &RenderAdapterInfo,
|
||||
device: &RenderDevice,
|
||||
queue: &RenderQueue,
|
||||
) -> DiagnosticsRecorder {
|
||||
let features = device.features();
|
||||
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
let tracy_gpu_context =
|
||||
super::tracy_gpu::new_tracy_gpu_context(adapter_info, device, queue);
|
||||
let _ = adapter_info; // Prevent unused variable warnings when tracing-tracy is not enabled
|
||||
|
||||
DiagnosticsRecorder(WgpuWrapper::new(DiagnosticsRecorderInternal {
|
||||
timestamp_period_ns: queue.get_timestamp_period(),
|
||||
features,
|
||||
current_frame: Mutex::new(FrameData::new(
|
||||
device,
|
||||
features,
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context.clone(),
|
||||
)),
|
||||
submitted_frames: Vec::new(),
|
||||
finished_frames: Vec::new(),
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context,
|
||||
}))
|
||||
}
|
||||
|
||||
fn current_frame_mut(&mut self) -> &mut FrameData {
|
||||
self.0.current_frame.get_mut().expect("lock poisoned")
|
||||
}
|
||||
|
||||
fn current_frame_lock(&self) -> impl DerefMut<Target = FrameData> + '_ {
|
||||
self.0.current_frame.lock().expect("lock poisoned")
|
||||
}
|
||||
|
||||
/// Begins recording diagnostics for a new frame.
|
||||
pub fn begin_frame(&mut self) {
|
||||
let internal = &mut self.0;
|
||||
let mut idx = 0;
|
||||
while idx < internal.submitted_frames.len() {
|
||||
let timestamp = internal.timestamp_period_ns;
|
||||
if internal.submitted_frames[idx].run_mapped_callback(timestamp) {
|
||||
let removed = internal.submitted_frames.swap_remove(idx);
|
||||
internal.finished_frames.push(removed);
|
||||
} else {
|
||||
idx += 1;
|
||||
}
|
||||
}
|
||||
|
||||
self.current_frame_mut().begin();
|
||||
}
|
||||
|
||||
/// Copies data from [`QuerySet`]'s to a [`Buffer`], after which it can be downloaded to CPU.
|
||||
///
|
||||
/// Should be called before [`DiagnosticsRecorder::finish_frame`].
|
||||
pub fn resolve(&mut self, encoder: &mut CommandEncoder) {
|
||||
self.current_frame_mut().resolve(encoder);
|
||||
}
|
||||
|
||||
/// Finishes recording diagnostics for the current frame.
|
||||
///
|
||||
/// The specified `callback` will be invoked when diagnostics become available.
|
||||
///
|
||||
/// Should be called after [`DiagnosticsRecorder::resolve`],
|
||||
/// and **after** all commands buffers have been queued.
|
||||
pub fn finish_frame(
|
||||
&mut self,
|
||||
device: &RenderDevice,
|
||||
callback: impl FnOnce(RenderDiagnostics) + Send + Sync + 'static,
|
||||
) {
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
let tracy_gpu_context = self.0.tracy_gpu_context.clone();
|
||||
|
||||
let internal = &mut self.0;
|
||||
internal
|
||||
.current_frame
|
||||
.get_mut()
|
||||
.expect("lock poisoned")
|
||||
.finish(callback);
|
||||
|
||||
// reuse one of the finished frames, if we can
|
||||
let new_frame = match internal.finished_frames.pop() {
|
||||
Some(frame) => frame,
|
||||
None => FrameData::new(
|
||||
device,
|
||||
internal.features,
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context,
|
||||
),
|
||||
};
|
||||
|
||||
let old_frame = core::mem::replace(
|
||||
internal.current_frame.get_mut().expect("lock poisoned"),
|
||||
new_frame,
|
||||
);
|
||||
internal.submitted_frames.push(old_frame);
|
||||
}
|
||||
}
|
||||
|
||||
impl RecordDiagnostics for DiagnosticsRecorder {
|
||||
fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, span_name: Cow<'static, str>) {
|
||||
self.current_frame_lock()
|
||||
.begin_time_span(encoder, span_name);
|
||||
}
|
||||
|
||||
fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E) {
|
||||
self.current_frame_lock().end_time_span(encoder);
|
||||
}
|
||||
|
||||
fn begin_pass_span<P: Pass>(&self, pass: &mut P, span_name: Cow<'static, str>) {
|
||||
self.current_frame_lock().begin_pass(pass, span_name);
|
||||
}
|
||||
|
||||
fn end_pass_span<P: Pass>(&self, pass: &mut P) {
|
||||
self.current_frame_lock().end_pass(pass);
|
||||
}
|
||||
}
|
||||
|
||||
struct SpanRecord {
|
||||
thread_id: ThreadId,
|
||||
path_range: Range<usize>,
|
||||
pass_kind: Option<PassKind>,
|
||||
begin_timestamp_index: Option<u32>,
|
||||
end_timestamp_index: Option<u32>,
|
||||
begin_instant: Option<Instant>,
|
||||
end_instant: Option<Instant>,
|
||||
pipeline_statistics_index: Option<u32>,
|
||||
}
|
||||
|
||||
struct FrameData {
|
||||
timestamps_query_set: Option<QuerySet>,
|
||||
num_timestamps: u32,
|
||||
supports_timestamps_inside_passes: bool,
|
||||
supports_timestamps_inside_encoders: bool,
|
||||
pipeline_statistics_query_set: Option<QuerySet>,
|
||||
num_pipeline_statistics: u32,
|
||||
buffer_size: u64,
|
||||
pipeline_statistics_buffer_offset: u64,
|
||||
resolve_buffer: Option<Buffer>,
|
||||
read_buffer: Option<Buffer>,
|
||||
path_components: Vec<Cow<'static, str>>,
|
||||
open_spans: Vec<SpanRecord>,
|
||||
closed_spans: Vec<SpanRecord>,
|
||||
is_mapped: Arc<AtomicBool>,
|
||||
callback: Option<Box<dyn FnOnce(RenderDiagnostics) + Send + Sync + 'static>>,
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context: tracy_client::GpuContext,
|
||||
}
|
||||
|
||||
impl FrameData {
|
||||
fn new(
|
||||
device: &RenderDevice,
|
||||
features: Features,
|
||||
#[cfg(feature = "tracing-tracy")] tracy_gpu_context: tracy_client::GpuContext,
|
||||
) -> FrameData {
|
||||
let wgpu_device = device.wgpu_device();
|
||||
let mut buffer_size = 0;
|
||||
|
||||
let timestamps_query_set = if features.contains(Features::TIMESTAMP_QUERY) {
|
||||
buffer_size += u64::from(MAX_TIMESTAMP_QUERIES) * TIMESTAMP_SIZE;
|
||||
Some(wgpu_device.create_query_set(&QuerySetDescriptor {
|
||||
label: Some("timestamps_query_set"),
|
||||
ty: QueryType::Timestamp,
|
||||
count: MAX_TIMESTAMP_QUERIES,
|
||||
}))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let pipeline_statistics_buffer_offset = buffer_size;
|
||||
|
||||
let pipeline_statistics_query_set =
|
||||
if features.contains(Features::PIPELINE_STATISTICS_QUERY) {
|
||||
buffer_size += u64::from(MAX_PIPELINE_STATISTICS) * PIPELINE_STATISTICS_SIZE;
|
||||
Some(wgpu_device.create_query_set(&QuerySetDescriptor {
|
||||
label: Some("pipeline_statistics_query_set"),
|
||||
ty: QueryType::PipelineStatistics(PipelineStatisticsTypes::all()),
|
||||
count: MAX_PIPELINE_STATISTICS,
|
||||
}))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let (resolve_buffer, read_buffer) = if buffer_size > 0 {
|
||||
let resolve_buffer = wgpu_device.create_buffer(&BufferDescriptor {
|
||||
label: Some("render_statistics_resolve_buffer"),
|
||||
size: buffer_size,
|
||||
usage: BufferUsages::QUERY_RESOLVE | BufferUsages::COPY_SRC,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let read_buffer = wgpu_device.create_buffer(&BufferDescriptor {
|
||||
label: Some("render_statistics_read_buffer"),
|
||||
size: buffer_size,
|
||||
usage: BufferUsages::COPY_DST | BufferUsages::MAP_READ,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
(Some(resolve_buffer), Some(read_buffer))
|
||||
} else {
|
||||
(None, None)
|
||||
};
|
||||
|
||||
FrameData {
|
||||
timestamps_query_set,
|
||||
num_timestamps: 0,
|
||||
supports_timestamps_inside_passes: features
|
||||
.contains(Features::TIMESTAMP_QUERY_INSIDE_PASSES),
|
||||
supports_timestamps_inside_encoders: features
|
||||
.contains(Features::TIMESTAMP_QUERY_INSIDE_ENCODERS),
|
||||
pipeline_statistics_query_set,
|
||||
num_pipeline_statistics: 0,
|
||||
buffer_size,
|
||||
pipeline_statistics_buffer_offset,
|
||||
resolve_buffer,
|
||||
read_buffer,
|
||||
path_components: Vec::new(),
|
||||
open_spans: Vec::new(),
|
||||
closed_spans: Vec::new(),
|
||||
is_mapped: Arc::new(AtomicBool::new(false)),
|
||||
callback: None,
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
tracy_gpu_context,
|
||||
}
|
||||
}
|
||||
|
||||
fn begin(&mut self) {
|
||||
self.num_timestamps = 0;
|
||||
self.num_pipeline_statistics = 0;
|
||||
self.path_components.clear();
|
||||
self.open_spans.clear();
|
||||
self.closed_spans.clear();
|
||||
}
|
||||
|
||||
fn write_timestamp(
|
||||
&mut self,
|
||||
encoder: &mut impl WriteTimestamp,
|
||||
is_inside_pass: bool,
|
||||
) -> Option<u32> {
|
||||
// `encoder.write_timestamp` is unsupported on WebGPU.
|
||||
if !self.supports_timestamps_inside_encoders {
|
||||
return None;
|
||||
}
|
||||
|
||||
if is_inside_pass && !self.supports_timestamps_inside_passes {
|
||||
return None;
|
||||
}
|
||||
|
||||
if self.num_timestamps >= MAX_TIMESTAMP_QUERIES {
|
||||
return None;
|
||||
}
|
||||
|
||||
let set = self.timestamps_query_set.as_ref()?;
|
||||
let index = self.num_timestamps;
|
||||
encoder.write_timestamp(set, index);
|
||||
self.num_timestamps += 1;
|
||||
Some(index)
|
||||
}
|
||||
|
||||
fn write_pipeline_statistics(
|
||||
&mut self,
|
||||
encoder: &mut impl WritePipelineStatistics,
|
||||
) -> Option<u32> {
|
||||
if self.num_pipeline_statistics >= MAX_PIPELINE_STATISTICS {
|
||||
return None;
|
||||
}
|
||||
|
||||
let set = self.pipeline_statistics_query_set.as_ref()?;
|
||||
let index = self.num_pipeline_statistics;
|
||||
encoder.begin_pipeline_statistics_query(set, index);
|
||||
self.num_pipeline_statistics += 1;
|
||||
Some(index)
|
||||
}
|
||||
|
||||
fn open_span(
|
||||
&mut self,
|
||||
pass_kind: Option<PassKind>,
|
||||
name: Cow<'static, str>,
|
||||
) -> &mut SpanRecord {
|
||||
let thread_id = thread::current().id();
|
||||
|
||||
let parent = self.open_spans.iter().rfind(|v| v.thread_id == thread_id);
|
||||
|
||||
let path_range = match &parent {
|
||||
Some(parent) if parent.path_range.end == self.path_components.len() => {
|
||||
parent.path_range.start..parent.path_range.end + 1
|
||||
}
|
||||
Some(parent) => {
|
||||
self.path_components
|
||||
.extend_from_within(parent.path_range.clone());
|
||||
self.path_components.len() - parent.path_range.len()..self.path_components.len() + 1
|
||||
}
|
||||
None => self.path_components.len()..self.path_components.len() + 1,
|
||||
};
|
||||
|
||||
self.path_components.push(name);
|
||||
|
||||
self.open_spans.push(SpanRecord {
|
||||
thread_id,
|
||||
path_range,
|
||||
pass_kind,
|
||||
begin_timestamp_index: None,
|
||||
end_timestamp_index: None,
|
||||
begin_instant: None,
|
||||
end_instant: None,
|
||||
pipeline_statistics_index: None,
|
||||
});
|
||||
|
||||
self.open_spans.last_mut().unwrap()
|
||||
}
|
||||
|
||||
fn close_span(&mut self) -> &mut SpanRecord {
|
||||
let thread_id = thread::current().id();
|
||||
|
||||
let iter = self.open_spans.iter();
|
||||
let (index, _) = iter
|
||||
.enumerate()
|
||||
.rfind(|(_, v)| v.thread_id == thread_id)
|
||||
.unwrap();
|
||||
|
||||
let span = self.open_spans.swap_remove(index);
|
||||
self.closed_spans.push(span);
|
||||
self.closed_spans.last_mut().unwrap()
|
||||
}
|
||||
|
||||
fn begin_time_span(&mut self, encoder: &mut impl WriteTimestamp, name: Cow<'static, str>) {
|
||||
let begin_instant = Instant::now();
|
||||
let begin_timestamp_index = self.write_timestamp(encoder, false);
|
||||
|
||||
let span = self.open_span(None, name);
|
||||
span.begin_instant = Some(begin_instant);
|
||||
span.begin_timestamp_index = begin_timestamp_index;
|
||||
}
|
||||
|
||||
fn end_time_span(&mut self, encoder: &mut impl WriteTimestamp) {
|
||||
let end_timestamp_index = self.write_timestamp(encoder, false);
|
||||
|
||||
let span = self.close_span();
|
||||
span.end_timestamp_index = end_timestamp_index;
|
||||
span.end_instant = Some(Instant::now());
|
||||
}
|
||||
|
||||
fn begin_pass<P: Pass>(&mut self, pass: &mut P, name: Cow<'static, str>) {
|
||||
let begin_instant = Instant::now();
|
||||
|
||||
let begin_timestamp_index = self.write_timestamp(pass, true);
|
||||
let pipeline_statistics_index = self.write_pipeline_statistics(pass);
|
||||
|
||||
let span = self.open_span(Some(P::KIND), name);
|
||||
span.begin_instant = Some(begin_instant);
|
||||
span.begin_timestamp_index = begin_timestamp_index;
|
||||
span.pipeline_statistics_index = pipeline_statistics_index;
|
||||
}
|
||||
|
||||
fn end_pass(&mut self, pass: &mut impl Pass) {
|
||||
let end_timestamp_index = self.write_timestamp(pass, true);
|
||||
|
||||
let span = self.close_span();
|
||||
span.end_timestamp_index = end_timestamp_index;
|
||||
|
||||
if span.pipeline_statistics_index.is_some() {
|
||||
pass.end_pipeline_statistics_query();
|
||||
}
|
||||
|
||||
span.end_instant = Some(Instant::now());
|
||||
}
|
||||
|
||||
fn resolve(&mut self, encoder: &mut CommandEncoder) {
|
||||
let Some(resolve_buffer) = &self.resolve_buffer else {
|
||||
return;
|
||||
};
|
||||
|
||||
match &self.timestamps_query_set {
|
||||
Some(set) if self.num_timestamps > 0 => {
|
||||
encoder.resolve_query_set(set, 0..self.num_timestamps, resolve_buffer, 0);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
match &self.pipeline_statistics_query_set {
|
||||
Some(set) if self.num_pipeline_statistics > 0 => {
|
||||
encoder.resolve_query_set(
|
||||
set,
|
||||
0..self.num_pipeline_statistics,
|
||||
resolve_buffer,
|
||||
self.pipeline_statistics_buffer_offset,
|
||||
);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let Some(read_buffer) = &self.read_buffer else {
|
||||
return;
|
||||
};
|
||||
|
||||
encoder.copy_buffer_to_buffer(resolve_buffer, 0, read_buffer, 0, self.buffer_size);
|
||||
}
|
||||
|
||||
fn diagnostic_path(&self, range: &Range<usize>, field: &str) -> DiagnosticPath {
|
||||
DiagnosticPath::from_components(
|
||||
core::iter::once("render")
|
||||
.chain(self.path_components[range.clone()].iter().map(|v| &**v))
|
||||
.chain(core::iter::once(field)),
|
||||
)
|
||||
}
|
||||
|
||||
fn finish(&mut self, callback: impl FnOnce(RenderDiagnostics) + Send + Sync + 'static) {
|
||||
let Some(read_buffer) = &self.read_buffer else {
|
||||
// we still have cpu timings, so let's use them
|
||||
|
||||
let mut diagnostics = Vec::new();
|
||||
|
||||
for span in &self.closed_spans {
|
||||
if let (Some(begin), Some(end)) = (span.begin_instant, span.end_instant) {
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "elapsed_cpu"),
|
||||
suffix: "ms",
|
||||
value: (end - begin).as_secs_f64() * 1000.0,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
callback(RenderDiagnostics(diagnostics));
|
||||
return;
|
||||
};
|
||||
|
||||
self.callback = Some(Box::new(callback));
|
||||
|
||||
let is_mapped = self.is_mapped.clone();
|
||||
read_buffer.slice(..).map_async(MapMode::Read, move |res| {
|
||||
if let Err(e) = res {
|
||||
tracing::warn!("Failed to download render statistics buffer: {e}");
|
||||
return;
|
||||
}
|
||||
|
||||
is_mapped.store(true, Ordering::Release);
|
||||
});
|
||||
}
|
||||
|
||||
// returns true if the frame is considered finished, false otherwise
|
||||
fn run_mapped_callback(&mut self, timestamp_period_ns: f32) -> bool {
|
||||
let Some(read_buffer) = &self.read_buffer else {
|
||||
return true;
|
||||
};
|
||||
if !self.is_mapped.load(Ordering::Acquire) {
|
||||
// need to wait more
|
||||
return false;
|
||||
}
|
||||
let Some(callback) = self.callback.take() else {
|
||||
return true;
|
||||
};
|
||||
|
||||
let data = read_buffer.slice(..).get_mapped_range();
|
||||
|
||||
let timestamps = data[..(self.num_timestamps * 8) as usize]
|
||||
.chunks(8)
|
||||
.map(|v| u64::from_le_bytes(v.try_into().unwrap()))
|
||||
.collect::<Vec<u64>>();
|
||||
|
||||
let start = self.pipeline_statistics_buffer_offset as usize;
|
||||
let len = (self.num_pipeline_statistics as usize) * 40;
|
||||
let pipeline_statistics = data[start..start + len]
|
||||
.chunks(8)
|
||||
.map(|v| u64::from_le_bytes(v.try_into().unwrap()))
|
||||
.collect::<Vec<u64>>();
|
||||
|
||||
let mut diagnostics = Vec::new();
|
||||
|
||||
for span in &self.closed_spans {
|
||||
if let (Some(begin), Some(end)) = (span.begin_instant, span.end_instant) {
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "elapsed_cpu"),
|
||||
suffix: "ms",
|
||||
value: (end - begin).as_secs_f64() * 1000.0,
|
||||
});
|
||||
}
|
||||
|
||||
if let (Some(begin), Some(end)) = (span.begin_timestamp_index, span.end_timestamp_index)
|
||||
{
|
||||
let begin = timestamps[begin as usize] as f64;
|
||||
let end = timestamps[end as usize] as f64;
|
||||
let value = (end - begin) * (timestamp_period_ns as f64) / 1e6;
|
||||
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
{
|
||||
// Calling span_alloc() and end_zone() here instead of in open_span() and close_span() means that tracy does not know where each GPU command was recorded on the CPU timeline.
|
||||
// Unfortunately we must do it this way, because tracy does not play nicely with multithreaded command recording. The start/end pairs would get all mixed up.
|
||||
// The GPU spans themselves are still accurate though, and it's probably safe to assume that each GPU span in frame N belongs to the corresponding CPU render node span from frame N-1.
|
||||
let name = &self.path_components[span.path_range.clone()].join("/");
|
||||
let mut tracy_gpu_span =
|
||||
self.tracy_gpu_context.span_alloc(name, "", "", 0).unwrap();
|
||||
tracy_gpu_span.end_zone();
|
||||
tracy_gpu_span.upload_timestamp_start(begin as i64);
|
||||
tracy_gpu_span.upload_timestamp_end(end as i64);
|
||||
}
|
||||
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "elapsed_gpu"),
|
||||
suffix: "ms",
|
||||
value,
|
||||
});
|
||||
}
|
||||
|
||||
if let Some(index) = span.pipeline_statistics_index {
|
||||
let index = (index as usize) * 5;
|
||||
|
||||
if span.pass_kind == Some(PassKind::Render) {
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "vertex_shader_invocations"),
|
||||
suffix: "",
|
||||
value: pipeline_statistics[index] as f64,
|
||||
});
|
||||
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "clipper_invocations"),
|
||||
suffix: "",
|
||||
value: pipeline_statistics[index + 1] as f64,
|
||||
});
|
||||
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "clipper_primitives_out"),
|
||||
suffix: "",
|
||||
value: pipeline_statistics[index + 2] as f64,
|
||||
});
|
||||
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "fragment_shader_invocations"),
|
||||
suffix: "",
|
||||
value: pipeline_statistics[index + 3] as f64,
|
||||
});
|
||||
}
|
||||
|
||||
if span.pass_kind == Some(PassKind::Compute) {
|
||||
diagnostics.push(RenderDiagnostic {
|
||||
path: self.diagnostic_path(&span.path_range, "compute_shader_invocations"),
|
||||
suffix: "",
|
||||
value: pipeline_statistics[index + 4] as f64,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
callback(RenderDiagnostics(diagnostics));
|
||||
|
||||
drop(data);
|
||||
read_buffer.unmap();
|
||||
self.is_mapped.store(false, Ordering::Release);
|
||||
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// Resource which stores render diagnostics of the most recent frame.
|
||||
#[derive(Debug, Default, Clone, Resource)]
|
||||
pub struct RenderDiagnostics(Vec<RenderDiagnostic>);
|
||||
|
||||
/// A render diagnostic which has been recorded, but not yet stored in [`DiagnosticsStore`].
|
||||
#[derive(Debug, Clone, Resource)]
|
||||
pub struct RenderDiagnostic {
|
||||
pub path: DiagnosticPath,
|
||||
pub suffix: &'static str,
|
||||
pub value: f64,
|
||||
}
|
||||
|
||||
/// Stores render diagnostics before they can be synced with the main app.
|
||||
///
|
||||
/// This mutex is locked twice per frame:
|
||||
/// 1. in `PreUpdate`, during [`sync_diagnostics`],
|
||||
/// 2. after rendering has finished and statistics have been downloaded from GPU.
|
||||
#[derive(Debug, Default, Clone, Resource)]
|
||||
pub struct RenderDiagnosticsMutex(pub(crate) Arc<Mutex<Option<RenderDiagnostics>>>);
|
||||
|
||||
/// Updates render diagnostics measurements.
|
||||
pub fn sync_diagnostics(mutex: Res<RenderDiagnosticsMutex>, mut store: ResMut<DiagnosticsStore>) {
|
||||
let Some(diagnostics) = mutex.0.lock().ok().and_then(|mut v| v.take()) else {
|
||||
return;
|
||||
};
|
||||
|
||||
let time = Instant::now();
|
||||
|
||||
for diagnostic in &diagnostics.0 {
|
||||
if store.get(&diagnostic.path).is_none() {
|
||||
store.add(Diagnostic::new(diagnostic.path.clone()).with_suffix(diagnostic.suffix));
|
||||
}
|
||||
|
||||
store
|
||||
.get_mut(&diagnostic.path)
|
||||
.unwrap()
|
||||
.add_measurement(DiagnosticMeasurement {
|
||||
time,
|
||||
value: diagnostic.value,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
pub trait WriteTimestamp {
|
||||
fn write_timestamp(&mut self, query_set: &QuerySet, index: u32);
|
||||
}
|
||||
|
||||
impl WriteTimestamp for CommandEncoder {
|
||||
fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
|
||||
if cfg!(target_os = "macos") {
|
||||
// When using tracy (and thus this function), rendering was flickering on macOS Tahoe.
|
||||
// See: https://github.com/bevyengine/bevy/issues/22257
|
||||
// The issue seems to be triggered when `write_timestamp` is called very close to frame
|
||||
// presentation.
|
||||
return;
|
||||
}
|
||||
CommandEncoder::write_timestamp(self, query_set, index);
|
||||
}
|
||||
}
|
||||
|
||||
impl WriteTimestamp for RenderPass<'_> {
|
||||
fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
|
||||
RenderPass::write_timestamp(self, query_set, index);
|
||||
}
|
||||
}
|
||||
|
||||
impl WriteTimestamp for ComputePass<'_> {
|
||||
fn write_timestamp(&mut self, query_set: &QuerySet, index: u32) {
|
||||
ComputePass::write_timestamp(self, query_set, index);
|
||||
}
|
||||
}
|
||||
|
||||
pub trait WritePipelineStatistics {
|
||||
fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32);
|
||||
|
||||
fn end_pipeline_statistics_query(&mut self);
|
||||
}
|
||||
|
||||
impl WritePipelineStatistics for RenderPass<'_> {
|
||||
fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
|
||||
RenderPass::begin_pipeline_statistics_query(self, query_set, index);
|
||||
}
|
||||
|
||||
fn end_pipeline_statistics_query(&mut self) {
|
||||
RenderPass::end_pipeline_statistics_query(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl WritePipelineStatistics for ComputePass<'_> {
|
||||
fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, index: u32) {
|
||||
ComputePass::begin_pipeline_statistics_query(self, query_set, index);
|
||||
}
|
||||
|
||||
fn end_pipeline_statistics_query(&mut self) {
|
||||
ComputePass::end_pipeline_statistics_query(self);
|
||||
}
|
||||
}
|
||||
|
||||
pub trait Pass: WritePipelineStatistics + WriteTimestamp {
|
||||
const KIND: PassKind;
|
||||
}
|
||||
|
||||
impl Pass for RenderPass<'_> {
|
||||
const KIND: PassKind = PassKind::Render;
|
||||
}
|
||||
|
||||
impl Pass for ComputePass<'_> {
|
||||
const KIND: PassKind = PassKind::Compute;
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
|
||||
pub enum PassKind {
|
||||
Render,
|
||||
Compute,
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
use bevy_app::{Plugin, PreUpdate};
|
||||
use bevy_diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic};
|
||||
use bevy_ecs::{resource::Resource, system::Res};
|
||||
use bevy_platform::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
|
||||
|
||||
use crate::{mesh::allocator::MeshAllocator, Extract, ExtractSchedule, RenderApp};
|
||||
|
||||
/// Number of meshes allocated by the allocator
|
||||
static MESH_ALLOCATOR_SLABS: DiagnosticPath = DiagnosticPath::const_new("mesh_allocator_slabs");
|
||||
|
||||
/// Total size of all slabs
|
||||
static MESH_ALLOCATOR_SLABS_SIZE: DiagnosticPath =
|
||||
DiagnosticPath::const_new("mesh_allocator_slabs_size");
|
||||
|
||||
/// Number of meshes allocated into slabs
|
||||
static MESH_ALLOCATOR_ALLOCATIONS: DiagnosticPath =
|
||||
DiagnosticPath::const_new("mesh_allocator_allocations");
|
||||
|
||||
pub struct MeshAllocatorDiagnosticPlugin;
|
||||
|
||||
impl MeshAllocatorDiagnosticPlugin {
|
||||
/// Get the [`DiagnosticPath`] for slab count
|
||||
pub fn slabs_diagnostic_path() -> &'static DiagnosticPath {
|
||||
&MESH_ALLOCATOR_SLABS
|
||||
}
|
||||
/// Get the [`DiagnosticPath`] for total slabs size
|
||||
pub fn slabs_size_diagnostic_path() -> &'static DiagnosticPath {
|
||||
&MESH_ALLOCATOR_SLABS_SIZE
|
||||
}
|
||||
/// Get the [`DiagnosticPath`] for mesh allocations
|
||||
pub fn allocations_diagnostic_path() -> &'static DiagnosticPath {
|
||||
&MESH_ALLOCATOR_ALLOCATIONS
|
||||
}
|
||||
}
|
||||
|
||||
impl Plugin for MeshAllocatorDiagnosticPlugin {
|
||||
fn build(&self, app: &mut bevy_app::App) {
|
||||
app.register_diagnostic(
|
||||
Diagnostic::new(MESH_ALLOCATOR_SLABS.clone()).with_suffix(" slabs"),
|
||||
)
|
||||
.register_diagnostic(
|
||||
Diagnostic::new(MESH_ALLOCATOR_SLABS_SIZE.clone()).with_suffix(" bytes"),
|
||||
)
|
||||
.register_diagnostic(
|
||||
Diagnostic::new(MESH_ALLOCATOR_ALLOCATIONS.clone()).with_suffix(" meshes"),
|
||||
)
|
||||
.init_resource::<MeshAllocatorMeasurements>()
|
||||
.add_systems(PreUpdate, add_mesh_allocator_measurement);
|
||||
|
||||
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
|
||||
render_app.add_systems(ExtractSchedule, measure_allocator);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Resource)]
|
||||
struct MeshAllocatorMeasurements {
|
||||
slabs: AtomicUsize,
|
||||
slabs_size: AtomicU64,
|
||||
allocations: AtomicUsize,
|
||||
}
|
||||
|
||||
fn add_mesh_allocator_measurement(
|
||||
mut diagnostics: Diagnostics,
|
||||
measurements: Res<MeshAllocatorMeasurements>,
|
||||
) {
|
||||
diagnostics.add_measurement(&MESH_ALLOCATOR_SLABS, || {
|
||||
measurements.slabs.load(Ordering::Relaxed) as f64
|
||||
});
|
||||
diagnostics.add_measurement(&MESH_ALLOCATOR_SLABS_SIZE, || {
|
||||
measurements.slabs_size.load(Ordering::Relaxed) as f64
|
||||
});
|
||||
diagnostics.add_measurement(&MESH_ALLOCATOR_ALLOCATIONS, || {
|
||||
measurements.allocations.load(Ordering::Relaxed) as f64
|
||||
});
|
||||
}
|
||||
|
||||
fn measure_allocator(
|
||||
measurements: Extract<Res<MeshAllocatorMeasurements>>,
|
||||
allocator: Res<MeshAllocator>,
|
||||
) {
|
||||
measurements
|
||||
.slabs
|
||||
.store(allocator.slab_count(), Ordering::Relaxed);
|
||||
measurements
|
||||
.slabs_size
|
||||
.store(allocator.slabs_size(), Ordering::Relaxed);
|
||||
measurements
|
||||
.allocations
|
||||
.store(allocator.allocations(), Ordering::Relaxed);
|
||||
}
|
||||
+199
@@ -0,0 +1,199 @@
|
||||
//! Infrastructure for recording render diagnostics.
|
||||
//!
|
||||
//! For more info, see [`RenderDiagnosticsPlugin`].
|
||||
|
||||
mod erased_render_asset_diagnostic_plugin;
|
||||
pub(crate) mod internal;
|
||||
mod mesh_allocator_diagnostic_plugin;
|
||||
mod render_asset_diagnostic_plugin;
|
||||
#[cfg(feature = "tracing-tracy")]
|
||||
mod tracy_gpu;
|
||||
|
||||
use alloc::{borrow::Cow, sync::Arc};
|
||||
use core::marker::PhantomData;
|
||||
|
||||
use bevy_app::{App, Plugin, PreUpdate};
|
||||
|
||||
use crate::{renderer::RenderAdapterInfo, RenderApp};
|
||||
|
||||
use self::internal::{
|
||||
sync_diagnostics, DiagnosticsRecorder, Pass, RenderDiagnosticsMutex, WriteTimestamp,
|
||||
};
|
||||
pub use self::{
|
||||
erased_render_asset_diagnostic_plugin::ErasedRenderAssetDiagnosticPlugin,
|
||||
mesh_allocator_diagnostic_plugin::MeshAllocatorDiagnosticPlugin,
|
||||
render_asset_diagnostic_plugin::RenderAssetDiagnosticPlugin,
|
||||
};
|
||||
|
||||
use crate::renderer::{RenderDevice, RenderQueue};
|
||||
|
||||
/// Enables collecting render diagnostics, such as CPU/GPU elapsed time per render pass,
|
||||
/// as well as pipeline statistics (number of primitives, number of shader invocations, etc).
|
||||
///
|
||||
/// To access the diagnostics, you can use the [`DiagnosticsStore`](bevy_diagnostic::DiagnosticsStore) resource,
|
||||
/// add [`LogDiagnosticsPlugin`](bevy_diagnostic::LogDiagnosticsPlugin), or use [Tracy](https://github.com/bevyengine/bevy/blob/main/docs/profiling.md#tracy-renderqueue).
|
||||
///
|
||||
/// To record diagnostics in your own passes:
|
||||
/// 1. First, obtain the diagnostic recorder using [`RenderContext::diagnostic_recorder`](crate::renderer::RenderContext::diagnostic_recorder).
|
||||
///
|
||||
/// It won't do anything unless [`RenderDiagnosticsPlugin`] is present,
|
||||
/// so you're free to omit `#[cfg]` clauses.
|
||||
/// ```ignore
|
||||
/// let diagnostics = render_context.diagnostic_recorder();
|
||||
/// ```
|
||||
/// 2. Begin the span inside a command encoder, or a render/compute pass encoder.
|
||||
/// ```ignore
|
||||
/// let time_span = diagnostics.time_span(render_context.command_encoder(), "shadows");
|
||||
/// ```
|
||||
/// 3. End the span, providing the same encoder.
|
||||
/// ```ignore
|
||||
/// time_span.end(render_context.command_encoder());
|
||||
/// ```
|
||||
///
|
||||
/// # Supported platforms
|
||||
/// Timestamp queries and pipeline statistics are currently supported only on Vulkan and DX12.
|
||||
/// On other platforms (Metal, WebGPU, WebGL2) only CPU time will be recorded.
|
||||
#[derive(Default)]
|
||||
pub struct RenderDiagnosticsPlugin;
|
||||
|
||||
impl Plugin for RenderDiagnosticsPlugin {
|
||||
fn build(&self, app: &mut App) {
|
||||
let render_diagnostics_mutex = RenderDiagnosticsMutex::default();
|
||||
app.insert_resource(render_diagnostics_mutex.clone())
|
||||
.add_systems(PreUpdate, sync_diagnostics);
|
||||
|
||||
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
|
||||
render_app.insert_resource(render_diagnostics_mutex);
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(&self, app: &mut App) {
|
||||
let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
|
||||
return;
|
||||
};
|
||||
|
||||
let adapter_info = render_app.world().resource::<RenderAdapterInfo>();
|
||||
let device = render_app.world().resource::<RenderDevice>();
|
||||
let queue = render_app.world().resource::<RenderQueue>();
|
||||
render_app.insert_resource(DiagnosticsRecorder::new(adapter_info, device, queue));
|
||||
}
|
||||
}
|
||||
|
||||
/// Allows recording diagnostic spans.
|
||||
pub trait RecordDiagnostics: Send + Sync {
|
||||
/// Begin a time span, which will record elapsed CPU and GPU time.
|
||||
///
|
||||
/// Returns a guard, which will panic on drop unless you end the span.
|
||||
fn time_span<E, N>(&self, encoder: &mut E, name: N) -> TimeSpanGuard<'_, Self, E>
|
||||
where
|
||||
E: WriteTimestamp,
|
||||
N: Into<Cow<'static, str>>,
|
||||
{
|
||||
self.begin_time_span(encoder, name.into());
|
||||
TimeSpanGuard {
|
||||
recorder: self,
|
||||
marker: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Begin a pass span, which will record elapsed CPU and GPU time,
|
||||
/// as well as pipeline statistics on supported platforms.
|
||||
///
|
||||
/// Returns a guard, which will panic on drop unless you end the span.
|
||||
fn pass_span<P, N>(&self, pass: &mut P, name: N) -> PassSpanGuard<'_, Self, P>
|
||||
where
|
||||
P: Pass,
|
||||
N: Into<Cow<'static, str>>,
|
||||
{
|
||||
let name = name.into();
|
||||
self.begin_pass_span(pass, name.clone());
|
||||
PassSpanGuard {
|
||||
recorder: self,
|
||||
name,
|
||||
marker: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, name: Cow<'static, str>);
|
||||
|
||||
#[doc(hidden)]
|
||||
fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E);
|
||||
|
||||
#[doc(hidden)]
|
||||
fn begin_pass_span<P: Pass>(&self, pass: &mut P, name: Cow<'static, str>);
|
||||
|
||||
#[doc(hidden)]
|
||||
fn end_pass_span<P: Pass>(&self, pass: &mut P);
|
||||
}
|
||||
|
||||
/// Guard returned by [`RecordDiagnostics::time_span`].
|
||||
///
|
||||
/// Will panic on drop unless [`TimeSpanGuard::end`] is called.
|
||||
pub struct TimeSpanGuard<'a, R: ?Sized, E> {
|
||||
recorder: &'a R,
|
||||
marker: PhantomData<E>,
|
||||
}
|
||||
|
||||
impl<R: RecordDiagnostics + ?Sized, E: WriteTimestamp> TimeSpanGuard<'_, R, E> {
|
||||
/// End the span. You have to provide the same encoder which was used to begin the span.
|
||||
pub fn end(self, encoder: &mut E) {
|
||||
self.recorder.end_time_span(encoder);
|
||||
core::mem::forget(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: ?Sized, E> Drop for TimeSpanGuard<'_, R, E> {
|
||||
fn drop(&mut self) {
|
||||
panic!("TimeSpanScope::end was never called")
|
||||
}
|
||||
}
|
||||
|
||||
/// Guard returned by [`RecordDiagnostics::pass_span`].
|
||||
///
|
||||
/// Will panic on drop unless [`PassSpanGuard::end`] is called.
|
||||
pub struct PassSpanGuard<'a, R: ?Sized, P> {
|
||||
recorder: &'a R,
|
||||
name: Cow<'static, str>,
|
||||
marker: PhantomData<P>,
|
||||
}
|
||||
|
||||
impl<R: RecordDiagnostics + ?Sized, P: Pass> PassSpanGuard<'_, R, P> {
|
||||
/// End the span. You have to provide the same pass which was used to begin the span.
|
||||
pub fn end(self, pass: &mut P) {
|
||||
self.recorder.end_pass_span(pass);
|
||||
core::mem::forget(self);
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: ?Sized, P> Drop for PassSpanGuard<'_, R, P> {
|
||||
fn drop(&mut self) {
|
||||
panic!("PassSpanGuard::end was never called for {}", self.name)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: RecordDiagnostics> RecordDiagnostics for Option<Arc<T>> {
|
||||
fn begin_time_span<E: WriteTimestamp>(&self, encoder: &mut E, name: Cow<'static, str>) {
|
||||
if let Some(recorder) = &self {
|
||||
recorder.begin_time_span(encoder, name);
|
||||
}
|
||||
}
|
||||
|
||||
fn end_time_span<E: WriteTimestamp>(&self, encoder: &mut E) {
|
||||
if let Some(recorder) = &self {
|
||||
recorder.end_time_span(encoder);
|
||||
}
|
||||
}
|
||||
|
||||
fn begin_pass_span<P: Pass>(&self, pass: &mut P, name: Cow<'static, str>) {
|
||||
if let Some(recorder) = &self {
|
||||
recorder.begin_pass_span(pass, name);
|
||||
}
|
||||
}
|
||||
|
||||
fn end_pass_span<P: Pass>(&self, pass: &mut P) {
|
||||
if let Some(recorder) = &self {
|
||||
recorder.end_pass_span(pass);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
use core::{any::type_name, marker::PhantomData};
|
||||
|
||||
use bevy_app::{Plugin, PreUpdate};
|
||||
use bevy_diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic};
|
||||
use bevy_ecs::{resource::Resource, system::Res};
|
||||
use bevy_platform::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use crate::{
|
||||
render_asset::{RenderAsset, RenderAssets},
|
||||
Extract, ExtractSchedule, RenderApp,
|
||||
};
|
||||
|
||||
pub struct RenderAssetDiagnosticPlugin<A: RenderAsset> {
|
||||
suffix: &'static str,
|
||||
_phantom: PhantomData<A>,
|
||||
}
|
||||
|
||||
impl<A: RenderAsset> RenderAssetDiagnosticPlugin<A> {
|
||||
pub fn new(suffix: &'static str) -> Self {
|
||||
Self {
|
||||
suffix,
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render_asset_diagnostic_path() -> DiagnosticPath {
|
||||
DiagnosticPath::from_components(["render_asset", type_name::<A>()])
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: RenderAsset> Plugin for RenderAssetDiagnosticPlugin<A> {
|
||||
fn build(&self, app: &mut bevy_app::App) {
|
||||
app.register_diagnostic(
|
||||
Diagnostic::new(Self::render_asset_diagnostic_path()).with_suffix(self.suffix),
|
||||
)
|
||||
.init_resource::<RenderAssetMeasurements<A>>()
|
||||
.add_systems(PreUpdate, add_render_asset_measurement::<A>);
|
||||
|
||||
if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
|
||||
render_app.add_systems(ExtractSchedule, measure_render_asset::<A>);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Resource)]
|
||||
struct RenderAssetMeasurements<A: RenderAsset> {
|
||||
assets: AtomicUsize,
|
||||
_phantom: PhantomData<A>,
|
||||
}
|
||||
|
||||
impl<A: RenderAsset> Default for RenderAssetMeasurements<A> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
assets: AtomicUsize::default(),
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn add_render_asset_measurement<A: RenderAsset>(
|
||||
mut diagnostics: Diagnostics,
|
||||
measurements: Res<RenderAssetMeasurements<A>>,
|
||||
) {
|
||||
diagnostics.add_measurement(
|
||||
&RenderAssetDiagnosticPlugin::<A>::render_asset_diagnostic_path(),
|
||||
|| measurements.assets.load(Ordering::Relaxed) as f64,
|
||||
);
|
||||
}
|
||||
|
||||
fn measure_render_asset<A: RenderAsset>(
|
||||
measurements: Extract<Res<RenderAssetMeasurements<A>>>,
|
||||
assets: Res<RenderAssets<A>>,
|
||||
) {
|
||||
measurements
|
||||
.assets
|
||||
.store(assets.iter().count(), Ordering::Relaxed);
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
use crate::renderer::{RenderAdapterInfo, RenderDevice, RenderQueue};
|
||||
use tracy_client::{Client, GpuContext, GpuContextType};
|
||||
use wgpu::{
|
||||
Backend, BufferDescriptor, BufferUsages, CommandEncoderDescriptor, MapMode, PollType,
|
||||
QuerySetDescriptor, QueryType, QUERY_SIZE,
|
||||
};
|
||||
|
||||
pub fn new_tracy_gpu_context(
|
||||
adapter_info: &RenderAdapterInfo,
|
||||
device: &RenderDevice,
|
||||
queue: &RenderQueue,
|
||||
) -> GpuContext {
|
||||
let tracy_gpu_backend = match adapter_info.backend {
|
||||
Backend::Vulkan => GpuContextType::Vulkan,
|
||||
Backend::Dx12 => GpuContextType::Direct3D12,
|
||||
Backend::Gl => GpuContextType::OpenGL,
|
||||
Backend::Metal | Backend::BrowserWebGpu | Backend::Noop => GpuContextType::Invalid,
|
||||
};
|
||||
|
||||
let tracy_client = Client::running().unwrap();
|
||||
tracy_client
|
||||
.new_gpu_context(
|
||||
Some("RenderQueue"),
|
||||
tracy_gpu_backend,
|
||||
initial_timestamp(device, queue),
|
||||
queue.get_timestamp_period(),
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
// Code copied from https://github.com/Wumpf/wgpu-profiler/blob/f9de342a62cb75f50904a98d11dd2bbeb40ceab8/src/tracy.rs
|
||||
fn initial_timestamp(device: &RenderDevice, queue: &RenderQueue) -> i64 {
|
||||
let query_set = device.wgpu_device().create_query_set(&QuerySetDescriptor {
|
||||
label: None,
|
||||
ty: QueryType::Timestamp,
|
||||
count: 1,
|
||||
});
|
||||
|
||||
let resolve_buffer = device.create_buffer(&BufferDescriptor {
|
||||
label: None,
|
||||
size: QUERY_SIZE as _,
|
||||
usage: BufferUsages::QUERY_RESOLVE | BufferUsages::COPY_SRC,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
|
||||
let map_buffer = device.create_buffer(&BufferDescriptor {
|
||||
label: None,
|
||||
size: QUERY_SIZE as _,
|
||||
usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
|
||||
let mut timestamp_encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
|
||||
timestamp_encoder.write_timestamp(&query_set, 0);
|
||||
timestamp_encoder.resolve_query_set(&query_set, 0..1, &resolve_buffer, 0);
|
||||
// Workaround for https://github.com/gfx-rs/wgpu/issues/6406
|
||||
// TODO when that bug is fixed, merge these encoders together again
|
||||
let mut copy_encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
|
||||
copy_encoder.copy_buffer_to_buffer(&resolve_buffer, 0, &map_buffer, 0, Some(QUERY_SIZE as _));
|
||||
queue.submit([timestamp_encoder.finish(), copy_encoder.finish()]);
|
||||
|
||||
map_buffer.slice(..).map_async(MapMode::Read, |_| ());
|
||||
device
|
||||
.poll(PollType::wait_indefinitely())
|
||||
.expect("Failed to poll device for map async");
|
||||
|
||||
let view = map_buffer.slice(..).get_mapped_range();
|
||||
i64::from_le_bytes((*view).try_into().unwrap())
|
||||
}
|
||||
Reference in new issue
Block a user