Does allocating without using actually take up memory?

stackinspector · September 5, 2023, 8:59pm

I wrote a tool that runs in multiple modes, some requiring a buffer, others do not. The buffer is created before mode-specific logics, meaning that the buffer is created whether it is used or not. The buffer is created using vec![0u8; buf_len], which calls "allocate zeroed" in the background. On x86_64-pc-windows-msvc, I observed that when running in modes that don't use a buffer, the taskmgr shows that the memory usage is less than the size of the buffer, i.e. the memory allocated for the buffer is not actually being used. Is this behavior consistent across all platforms that can use std? Do I need to add logic that determines whether a buffer is needed and thus whether it is created? I think this may be an OS internal level optimization, so the behavior is not guaranteed.

quinedot · September 5, 2023, 9:07pm

Optimizations like that could come from multiple places

The compiler / LLVM
Or like you said, the OS (might give you a fake page and then upon fault when you try to read or write it, actually find the memory for you... or OOM you)

Neither are guarantees. Whether it's worth it to add your own logic depends on your use case (maybe an actual allocation wouldn't matter in practice) and how comfortable you are relying on non-guaranteed optimizations (if it would matter).

xfix · September 5, 2023, 9:48pm

vec![0u8; size] is special in that it will allocate memory initialized to zero (on Windows, it's calling HeapAlloc with HEAP_ZERO_MEMORY flag set).

github.com

rust-lang/rust/blob/master/library/alloc/src/vec/spec_from_elem.rs

use core::ptr;

use crate::alloc::Allocator;
use crate::raw_vec::RawVec;

use super::{IsZero, Vec};

// Specialization trait used for Vec::from_elem
pub(super) trait SpecFromElem: Sized {
    fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A>;
}

impl<T: Clone> SpecFromElem for T {
    default fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A> {
        let mut v = Vec::with_capacity_in(n, alloc);
        v.extend_with(n, elem);
        v
    }
}

This file has been truncated. show original

Windows when dealing with large allocations may not actually commit the memory pages until you actually access them.

As mentioned above, neither of those are guarantees. Rust may decide to not special-case allocations for elements whose representation is all zero, and Windows at any point can decide to change its allocator behavior.