wgpu_types/
counters.rs

1use alloc::{string::String, vec::Vec};
2#[cfg(feature = "counters")]
3use core::sync::atomic::{AtomicIsize, Ordering};
4use core::{fmt, ops::Range};
5
6/// An internal counter for debugging purposes
7///
8/// Internally represented as an atomic isize if the `counters` feature is enabled,
9/// or compiles to nothing otherwise.
10pub struct InternalCounter {
11    #[cfg(feature = "counters")]
12    value: AtomicIsize,
13}
14
15impl InternalCounter {
16    /// Creates a counter with value 0.
17    #[inline]
18    #[must_use]
19    pub const fn new() -> Self {
20        InternalCounter {
21            #[cfg(feature = "counters")]
22            value: AtomicIsize::new(0),
23        }
24    }
25
26    /// Get the counter's value.
27    #[cfg(feature = "counters")]
28    #[inline]
29    pub fn read(&self) -> isize {
30        self.value.load(Ordering::Relaxed)
31    }
32
33    /// Get the counter's value.
34    ///
35    /// Always returns 0 if the `counters` feature is not enabled.
36    #[cfg(not(feature = "counters"))]
37    #[inline]
38    #[must_use]
39    pub fn read(&self) -> isize {
40        0
41    }
42
43    /// Get and reset the counter's value.
44    ///
45    /// Always returns 0 if the `counters` feature is not enabled.
46    #[cfg(feature = "counters")]
47    #[inline]
48    pub fn take(&self) -> isize {
49        self.value.swap(0, Ordering::Relaxed)
50    }
51
52    /// Get and reset the counter's value.
53    ///
54    /// Always returns 0 if the `counters` feature is not enabled.
55    #[cfg(not(feature = "counters"))]
56    #[inline]
57    #[must_use]
58    pub fn take(&self) -> isize {
59        0
60    }
61
62    /// Increment the counter by the provided amount.
63    #[inline]
64    pub fn add(&self, _val: isize) {
65        #[cfg(feature = "counters")]
66        self.value.fetch_add(_val, Ordering::Relaxed);
67    }
68
69    /// Decrement the counter by the provided amount.
70    #[inline]
71    pub fn sub(&self, _val: isize) {
72        #[cfg(feature = "counters")]
73        self.value.fetch_add(-_val, Ordering::Relaxed);
74    }
75
76    /// Sets the counter to the provided value.
77    #[inline]
78    pub fn set(&self, _val: isize) {
79        #[cfg(feature = "counters")]
80        self.value.store(_val, Ordering::Relaxed);
81    }
82}
83
84impl Clone for InternalCounter {
85    fn clone(&self) -> Self {
86        InternalCounter {
87            #[cfg(feature = "counters")]
88            value: AtomicIsize::new(self.read()),
89        }
90    }
91}
92
93impl Default for InternalCounter {
94    fn default() -> Self {
95        Self::new()
96    }
97}
98
99impl core::fmt::Debug for InternalCounter {
100    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
101        self.read().fmt(f)
102    }
103}
104
105/// `wgpu-hal`'s internal counters.
106#[allow(missing_docs)]
107#[derive(Clone, Default)]
108pub struct HalCounters {
109    // API objects
110    pub buffers: InternalCounter,
111    pub textures: InternalCounter,
112    pub texture_views: InternalCounter,
113    pub bind_groups: InternalCounter,
114    pub bind_group_layouts: InternalCounter,
115    pub render_pipelines: InternalCounter,
116    pub compute_pipelines: InternalCounter,
117    pub pipeline_layouts: InternalCounter,
118    pub samplers: InternalCounter,
119    pub command_encoders: InternalCounter,
120    pub shader_modules: InternalCounter,
121    pub query_sets: InternalCounter,
122    pub fences: InternalCounter,
123
124    // Resources
125    /// Amount of allocated gpu memory attributed to buffers, in bytes.
126    pub buffer_memory: InternalCounter,
127    /// Amount of allocated gpu memory attributed to textures, in bytes.
128    pub texture_memory: InternalCounter,
129    /// Amount of allocated gpu memory attributed to acceleration structures, in bytes.
130    pub acceleration_structure_memory: InternalCounter,
131    /// Number of gpu memory allocations.
132    pub memory_allocations: InternalCounter,
133}
134
135/// `wgpu-core`'s internal counters.
136#[derive(Clone, Default)]
137pub struct CoreCounters {
138    // TODO    #[cfg(features=)]
139}
140
141/// All internal counters, exposed for debugging purposes.
142#[derive(Clone, Default)]
143pub struct InternalCounters {
144    /// `wgpu-core` counters.
145    pub core: CoreCounters,
146    /// `wgpu-hal` counters.
147    pub hal: HalCounters,
148}
149
150/// Describes an allocation in the [`AllocatorReport`].
151#[derive(Clone)]
152pub struct AllocationReport {
153    /// The name provided to the `allocate()` function.
154    pub name: String,
155    /// The offset in bytes of the allocation in its memory block.
156    pub offset: u64,
157    /// The size in bytes of the allocation.
158    pub size: u64,
159}
160
161/// Describes a memory block in the [`AllocatorReport`].
162#[derive(Clone)]
163pub struct MemoryBlockReport {
164    /// The size in bytes of this memory block.
165    pub size: u64,
166    /// The range of allocations in [`AllocatorReport::allocations`] that are associated
167    /// to this memory block.
168    pub allocations: Range<usize>,
169}
170
171/// A report that can be generated for informational purposes using `Allocator::generate_report()`.
172#[derive(Clone)]
173pub struct AllocatorReport {
174    /// All live allocations, sub-allocated from memory blocks.
175    pub allocations: Vec<AllocationReport>,
176    /// All memory blocks.
177    pub blocks: Vec<MemoryBlockReport>,
178    /// Sum of the memory used by all allocations, in bytes.
179    pub total_allocated_bytes: u64,
180    /// Sum of the memory reserved by all memory blocks including unallocated regions, in bytes.
181    pub total_reserved_bytes: u64,
182}
183
184impl fmt::Debug for AllocationReport {
185    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
186        let name = if !self.name.is_empty() {
187            self.name.as_str()
188        } else {
189            "--"
190        };
191        write!(f, "{name:?}: {}", FmtBytes(self.size))
192    }
193}
194
195impl fmt::Debug for AllocatorReport {
196    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
197        let mut allocations = self.allocations.clone();
198        allocations.sort_by_key(|alloc| core::cmp::Reverse(alloc.size));
199
200        let max_num_allocations_to_print = f.precision().unwrap_or(usize::MAX);
201        allocations.truncate(max_num_allocations_to_print);
202
203        f.debug_struct("AllocatorReport")
204            .field(
205                "summary",
206                &core::format_args!(
207                    "{} / {}",
208                    FmtBytes(self.total_allocated_bytes),
209                    FmtBytes(self.total_reserved_bytes)
210                ),
211            )
212            .field("blocks", &self.blocks.len())
213            .field("allocations", &self.allocations.len())
214            .field("largest", &allocations.as_slice())
215            .finish()
216    }
217}
218
219struct FmtBytes(u64);
220
221impl fmt::Display for FmtBytes {
222    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
223        const SUFFIX: [&str; 5] = ["B", "KB", "MB", "GB", "TB"];
224        let mut idx = 0;
225        let mut amount = self.0 as f64;
226        loop {
227            if amount < 1024.0 || idx == SUFFIX.len() - 1 {
228                return write!(f, "{:.2} {}", amount, SUFFIX[idx]);
229            }
230
231            amount /= 1024.0;
232            idx += 1;
233        }
234    }
235}
wgpu_types/counters.rs

wgpu_types/
counters.rs
