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 part of [`InternalCounters`].
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 part of [`InternalCounters`].
136#[derive(Clone, Default)]
137pub struct CoreCounters {
138    // TODO    #[cfg(features=)]
139}
140
141/// All internal counters, exposed for debugging purposes.
142///
143/// Obtain this from
144/// [`Device::get_internal_counters()`](../wgpu/struct.Device.html#method.get_internal_counters).
145#[derive(Clone, Default)]
146pub struct InternalCounters {
147    /// `wgpu-core` counters.
148    pub core: CoreCounters,
149    /// `wgpu-hal` counters.
150    pub hal: HalCounters,
151}
152
153/// Describes an allocation in the [`AllocatorReport`].
154#[derive(Clone)]
155pub struct AllocationReport {
156    /// The name provided to the `allocate()` function.
157    pub name: String,
158    /// The offset in bytes of the allocation in its memory block.
159    pub offset: u64,
160    /// The size in bytes of the allocation.
161    pub size: u64,
162}
163
164/// Describes a memory block in the [`AllocatorReport`].
165#[derive(Clone)]
166pub struct MemoryBlockReport {
167    /// The size in bytes of this memory block.
168    pub size: u64,
169    /// The range of allocations in [`AllocatorReport::allocations`] that are associated
170    /// to this memory block.
171    pub allocations: Range<usize>,
172}
173
174/// A report that can be generated for informational purposes using `Allocator::generate_report()`.
175#[derive(Clone)]
176pub struct AllocatorReport {
177    /// All live allocations, sub-allocated from memory blocks.
178    pub allocations: Vec<AllocationReport>,
179    /// All memory blocks.
180    pub blocks: Vec<MemoryBlockReport>,
181    /// Sum of the memory used by all allocations, in bytes.
182    pub total_allocated_bytes: u64,
183    /// Sum of the memory reserved by all memory blocks including unallocated regions, in bytes.
184    pub total_reserved_bytes: u64,
185}
186
187impl fmt::Debug for AllocationReport {
188    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
189        let name = if !self.name.is_empty() {
190            self.name.as_str()
191        } else {
192            "--"
193        };
194        write!(f, "{name:?}: {}", FmtBytes(self.size))
195    }
196}
197
198impl fmt::Debug for AllocatorReport {
199    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
200        let mut allocations = self.allocations.clone();
201        allocations.sort_by_key(|alloc| core::cmp::Reverse(alloc.size));
202
203        let max_num_allocations_to_print = f.precision().unwrap_or(usize::MAX);
204        allocations.truncate(max_num_allocations_to_print);
205
206        f.debug_struct("AllocatorReport")
207            .field(
208                "summary",
209                &core::format_args!(
210                    "{} / {}",
211                    FmtBytes(self.total_allocated_bytes),
212                    FmtBytes(self.total_reserved_bytes)
213                ),
214            )
215            .field("blocks", &self.blocks.len())
216            .field("allocations", &self.allocations.len())
217            .field("largest", &allocations.as_slice())
218            .finish()
219    }
220}
221
222struct FmtBytes(u64);
223
224impl fmt::Display for FmtBytes {
225    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
226        const SUFFIX: [&str; 5] = ["B", "KB", "MB", "GB", "TB"];
227        let mut idx = 0;
228        let mut amount = self.0 as f64;
229        loop {
230            if amount < 1024.0 || idx == SUFFIX.len() - 1 {
231                return write!(f, "{:.2} {}", amount, SUFFIX[idx]);
232            }
233
234            amount /= 1024.0;
235            idx += 1;
236        }
237    }
238}
wgpu_types/counters.rs

wgpu_types/
counters.rs
