#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BuildStep {
Validate,
Pack,
RayBvh,
Ranges,
Clusters,
Place,
Write,
StaticInstanceBvh,
MovingInstanceBvh,
}
#[cfg(any(test, feature = "diagnostics"))]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct UploadSite {
pub file: &'static str,
pub line: u32,
pub bytes: u64,
pub writes: u64,
}
#[cfg(any(test, feature = "diagnostics"))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct StepTime {
pub step: BuildStep,
pub calls: u64,
pub nanoseconds: u64,
}
#[cfg(any(test, feature = "diagnostics"))]
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Counters {
pub uploads: Vec<UploadSite>,
pub buffers_created: u64,
pub steps: Vec<StepTime>,
pub ray_source_growths: u64,
pub geometry_growths: u64,
pub static_edit_boxes: u64,
pub static_edit_boxes_merged: u64,
pub blas_builds: u64,
pub blas_build_vertices: u64,
pub deformed_blas_builds: u64,
pub tlas_builds: u64,
pub blas_compactions: u64,
pub blas_compacted_vertices: u64,
}
#[cfg(any(test, feature = "diagnostics"))]
impl Counters {
pub fn uploaded_bytes(&self) -> u64 {
self.uploads.iter().map(|site| site.bytes).sum()
}
pub fn step(&self, step: BuildStep) -> StepTime {
self.steps
.iter()
.find(|time| time.step == step)
.copied()
.unwrap_or(StepTime {
step,
calls: 0,
nanoseconds: 0,
})
}
pub fn since(&self, earlier: &Counters) -> Counters {
let uploads = self
.uploads
.iter()
.filter_map(|site| {
let before = earlier
.uploads
.iter()
.find(|old| old.line == site.line && old.file == site.file);
let bytes = site.bytes - before.map_or(0, |old| old.bytes);
let writes = site.writes - before.map_or(0, |old| old.writes);
(writes > 0).then(|| UploadSite {
bytes,
writes,
..site.clone()
})
})
.collect();
let steps = self
.steps
.iter()
.map(|time| {
let before = earlier.step(time.step);
StepTime {
calls: time.calls - before.calls,
nanoseconds: time.nanoseconds - before.nanoseconds,
..*time
}
})
.filter(|time| time.calls > 0)
.collect();
Counters {
uploads,
buffers_created: self.buffers_created - earlier.buffers_created,
steps,
ray_source_growths: self.ray_source_growths - earlier.ray_source_growths,
geometry_growths: self.geometry_growths - earlier.geometry_growths,
static_edit_boxes: self.static_edit_boxes - earlier.static_edit_boxes,
static_edit_boxes_merged: self.static_edit_boxes_merged
- earlier.static_edit_boxes_merged,
blas_builds: self.blas_builds - earlier.blas_builds,
blas_build_vertices: self.blas_build_vertices - earlier.blas_build_vertices,
deformed_blas_builds: self.deformed_blas_builds - earlier.deformed_blas_builds,
tlas_builds: self.tlas_builds - earlier.tlas_builds,
blas_compactions: self.blas_compactions - earlier.blas_compactions,
blas_compacted_vertices: self.blas_compacted_vertices - earlier.blas_compacted_vertices,
}
}
}
#[cfg(any(test, feature = "diagnostics"))]
thread_local! {
static COUNTERS: std::cell::RefCell<Counters> = std::cell::RefCell::default();
}
#[cfg(any(test, feature = "diagnostics"))]
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
fn upload(bytes: usize) {
let at = std::panic::Location::caller();
COUNTERS.with_borrow_mut(|counters| {
let at_site = |site: &UploadSite| site.line == at.line() && site.file == at.file();
if !counters.uploads.iter().any(at_site) {
counters.uploads.push(UploadSite {
file: at.file(),
line: at.line(),
bytes: 0,
writes: 0,
});
}
let site = counters
.uploads
.iter_mut()
.find(|site| at_site(site))
.unwrap();
site.bytes += bytes as u64;
site.writes += 1;
});
}
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
pub(crate) fn write_buffer(queue: &wgpu::Queue, buffer: &wgpu::Buffer, offset: u64, data: &[u8]) {
#[cfg(any(test, feature = "diagnostics"))]
upload(data.len());
queue.write_buffer(buffer, offset, data);
}
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
pub(crate) fn write_texture(
queue: &wgpu::Queue,
texture: wgpu::TexelCopyTextureInfo<'_>,
data: &[u8],
layout: wgpu::TexelCopyBufferLayout,
size: wgpu::Extent3d,
) {
#[cfg(any(test, feature = "diagnostics"))]
upload(data.len());
queue.write_texture(texture, data, layout, size);
}
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
pub(crate) fn buffer(
device: &wgpu::Device,
descriptor: &wgpu::BufferDescriptor<'_>,
) -> wgpu::Buffer {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| counters.buffers_created += 1);
device.create_buffer(descriptor)
}
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
pub(crate) fn buffer_init(
device: &wgpu::Device,
descriptor: &wgpu::util::BufferInitDescriptor<'_>,
) -> wgpu::Buffer {
use wgpu::util::DeviceExt;
#[cfg(any(test, feature = "diagnostics"))]
{
upload(descriptor.contents.len());
COUNTERS.with_borrow_mut(|counters| counters.buffers_created += 1);
}
device.create_buffer_init(descriptor)
}
#[cfg_attr(any(test, feature = "diagnostics"), track_caller)]
pub(crate) fn texture_init(
device: &wgpu::Device,
queue: &wgpu::Queue,
descriptor: &wgpu::TextureDescriptor<'_>,
order: wgpu::util::TextureDataOrder,
data: &[u8],
) -> wgpu::Texture {
use wgpu::util::DeviceExt;
#[cfg(any(test, feature = "diagnostics"))]
upload(data.len());
device.create_texture_with_data(queue, descriptor, order, data)
}
#[derive(Clone, Copy)]
pub(crate) struct Moment {
#[cfg(all(any(test, feature = "diagnostics"), not(target_arch = "wasm32")))]
at: std::time::Instant,
#[cfg(all(feature = "diagnostics", target_arch = "wasm32"))]
at: f64,
}
impl Moment {
pub fn now() -> Self {
Self {
#[cfg(all(any(test, feature = "diagnostics"), not(target_arch = "wasm32")))]
at: std::time::Instant::now(),
#[cfg(all(feature = "diagnostics", target_arch = "wasm32"))]
at: performance_now(),
}
}
pub fn elapsed_ms(self) -> f64 {
#[cfg(all(any(test, feature = "diagnostics"), not(target_arch = "wasm32")))]
let elapsed = self.at.elapsed().as_secs_f64() * 1e3;
#[cfg(all(feature = "diagnostics", target_arch = "wasm32"))]
let elapsed = performance_now() - self.at;
#[cfg(not(any(
all(any(test, feature = "diagnostics"), not(target_arch = "wasm32")),
all(feature = "diagnostics", target_arch = "wasm32")
)))]
let elapsed = {
let _ = self;
0.
};
elapsed
}
}
#[cfg(all(feature = "diagnostics", target_arch = "wasm32"))]
fn performance_now() -> f64 {
use js_sys::wasm_bindgen::{JsCast, JsValue};
thread_local! {
static NOW: Option<(JsValue, js_sys::Function)> = {
let performance = js_sys::Reflect::get(&js_sys::global(), &"performance".into()).ok();
performance.and_then(|performance| {
let now = js_sys::Reflect::get(&performance, &"now".into()).ok()?;
Some((performance, now.dyn_into().ok()?))
})
};
}
NOW.with(|now| {
now.as_ref()
.and_then(|(performance, now)| now.call0(performance).ok()?.as_f64())
.unwrap_or(0.)
})
}
pub(crate) fn step<T>(step: BuildStep, work: impl FnOnce() -> T) -> T {
#[cfg(any(test, feature = "diagnostics"))]
{
let started = Moment::now();
let result = work();
let nanoseconds = (started.elapsed_ms() * 1e6) as u64;
COUNTERS.with_borrow_mut(|counters| {
if !counters.steps.iter().any(|time| time.step == step) {
counters.steps.push(StepTime {
step,
calls: 0,
nanoseconds: 0,
});
}
let time = counters
.steps
.iter_mut()
.find(|time| time.step == step)
.unwrap();
time.calls += 1;
time.nanoseconds += nanoseconds;
});
result
}
#[cfg(not(any(test, feature = "diagnostics")))]
{
let _ = step;
work()
}
}
pub(crate) fn ray_source_growth() {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| counters.ray_source_growths += 1);
}
pub(crate) fn geometry_growth() {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| counters.geometry_growths += 1);
}
pub(crate) fn static_edit(merged: usize) {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| {
counters.static_edit_boxes += 1;
counters.static_edit_boxes_merged += merged as u64;
});
#[cfg(not(any(test, feature = "diagnostics")))]
let _ = merged;
}
pub(crate) fn blas_build(vertices: u32) {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| {
counters.blas_builds += 1;
counters.blas_build_vertices += u64::from(vertices);
});
#[cfg(not(any(test, feature = "diagnostics")))]
let _ = vertices;
}
pub(crate) fn deformed_blas_build() {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| counters.deformed_blas_builds += 1);
}
pub(crate) fn tlas_build() {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| counters.tlas_builds += 1);
}
pub(crate) fn blas_compaction(vertices: u32) {
#[cfg(any(test, feature = "diagnostics"))]
COUNTERS.with_borrow_mut(|counters| {
counters.blas_compactions += 1;
counters.blas_compacted_vertices += u64::from(vertices);
});
#[cfg(not(any(test, feature = "diagnostics")))]
let _ = vertices;
}
#[cfg(any(test, feature = "diagnostics"))]
pub(crate) fn snapshot() -> Counters {
COUNTERS.with_borrow(Clone::clone)
}