Files
ab_glyph_rasterizer
addr2line
adler
andrew
approx
arrayvec
ash
atom
backtrace
bitflags
byteorder
calloop
cfg_if
colorful
conrod_core
conrod_derive
conrod_example_shared
conrod_gfx
conrod_glium
conrod_piston
conrod_rendy
conrod_vulkano
conrod_wgpu
conrod_winit
copyless
copypasta
crossbeam
crossbeam_channel
crossbeam_deque
crossbeam_epoch
crossbeam_queue
crossbeam_utils
daggy
dlib
downcast_rs
draw_state
either
fixedbitset
float
fnv
futures
futures_channel
futures_core
futures_executor
futures_io
futures_macro
futures_sink
futures_task
futures_util
async_await
future
io
lock
sink
stream
task
fxhash
getrandom
gfx
gfx_backend_empty
gfx_backend_vulkan
gfx_core
gfx_descriptor
gfx_hal
gfx_memory
gimli
glium
glutin
glutin_egl_sys
glutin_glx_sys
graphics
half
hibitset
inplace_it
input
instant
interpolation
iovec
itoa
lazy_static
lazycell
libc
libloading
line_drawing
linked_hash_map
lock_api
log
maybe_uninit
memchr
memmap
memoffset
miniz_oxide
mio
mio_extras
naga
net2
nix
nom
num
num_bigint
num_complex
num_cpus
num_integer
num_iter
num_rational
num_traits
object
once_cell
ordered_float
ordermap
osmesa_sys
owned_ttf_parser
parking_lot
parking_lot_core
percent_encoding
petgraph
pin_project
pin_project_internal
pin_project_lite
pin_utils
ppv_lite86
proc_macro2
proc_macro_hack
proc_macro_nested
quote
rand
rand_chacha
rand_core
raw_window_handle
read_color
relevant
rendy
rendy_chain
rendy_command
rendy_core
rendy_descriptor
rendy_factory
rendy_frame
rendy_graph
rendy_init
rendy_memory
rendy_mesh
rendy_resource
rendy_shader
rendy_texture
rendy_wsi
rustc_demangle
rustc_hash
rusttype
ryu
same_file
scoped_tls
scopeguard
serde
serde_derive
serde_json
shaderc
shaderc_sys
shared_library
slab
smallvec
smithay_client_toolkit
smithay_clipboard
spirv_headers
stb_truetype
syn
takeable_option
texture
thiserror
thiserror_impl
thread_profiler
time
tracing
tracing_core
ttf_parser
typed_arena
unicode_xid
vecmath
viewport
vk_sys
void
vulkano
buffer
command_buffer
descriptor
device
framebuffer
image
instance
memory
pipeline
query
swapchain
sync
vulkano_shaders
walkdir
wayland_client
wayland_commons
wayland_cursor
wayland_egl
wayland_protocols
wayland_sys
wgpu
wgpu_core
wgpu_types
winit
x11
x11_clipboard
x11_dl
xcb
xcursor
xdg
xml
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//! GPU memory management
//!

#![warn(
    missing_docs,
    trivial_casts,
    trivial_numeric_casts,
    unused_extern_crates,
    unused_import_braces,
    unused_qualifications
)]
#[allow(clippy::new_without_default)]
mod allocator;
mod block;
mod heaps;
mod mapping;
mod memory;
mod stats;
mod usage;

pub use crate::{
    allocator::*,
    block::Block,
    heaps::{Heaps, HeapsError, MemoryBlock},
    mapping::{MappedRange, Writer},
    memory::Memory,
    stats::*,
    usage::MemoryUsage,
};

use std::ops::Range;

/// Type for any memory sizes.
pub type Size = u64;
/// Type for non-coherent atom sizes.
pub type AtomSize = std::num::NonZeroU64;

fn is_non_coherent_visible(properties: hal::memory::Properties) -> bool {
    properties.contains(hal::memory::Properties::CPU_VISIBLE)
        && !properties.contains(hal::memory::Properties::COHERENT)
}

fn align_range(range: &Range<Size>, align: AtomSize) -> Range<Size> {
    let start = range.start - range.start % align.get();
    let end = ((range.end - 1) / align.get() + 1) * align.get();
    start..end
}

fn align_size(size: Size, align: AtomSize) -> Size {
    ((size - 1) / align.get() + 1) * align.get()
}

fn align_offset(value: Size, align: AtomSize) -> Size {
    debug_assert_eq!(align.get().count_ones(), 1);
    if value == 0 {
        0
    } else {
        1 + ((value - 1) | (align.get() - 1))
    }
}

fn segment_to_sub_range(
    segment: hal::memory::Segment,
    whole: &Range<Size>,
) -> Result<Range<Size>, hal::device::MapError> {
    let start = whole.start + segment.offset;
    match segment.size {
        Some(s) if start + s <= whole.end => Ok(start..start + s),
        None if start < whole.end => Ok(start..whole.end),
        _ => Err(hal::device::MapError::OutOfBounds),
    }
}

fn is_sub_range(sub: &Range<Size>, range: &Range<Size>) -> bool {
    sub.start >= range.start && sub.end <= range.end
}