pub struct System;Expand description
The default memory allocator provided by the operating system.
This is based on malloc on Unix platforms and HeapAlloc on Windows,
plus related functions.
This type implements the GlobalAlloc trait and Rust programs by default
work as if they had this definition:
use std::alloc::System;
#[global_allocator]
static A: System = System;
fn main() {
let a = Box::new(4); // Allocates from the system allocator.
println!("{}", a);
}You can also define your own wrapper around System if you’d like, such as
keeping track of the number of all bytes allocated:
use std::alloc::{System, GlobalAlloc, Layout};
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
struct Counter;
static ALLOCATED: AtomicUsize = AtomicUsize::new(0);
unsafe impl GlobalAlloc for Counter {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
let ret = System.alloc(layout);
if !ret.is_null() {
ALLOCATED.fetch_add(layout.size(), SeqCst);
}
return ret
}
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
System.dealloc(ptr, layout);
ALLOCATED.fetch_sub(layout.size(), SeqCst);
}
}
#[global_allocator]
static A: Counter = Counter;
fn main() {
println!("allocated bytes before main: {}", ALLOCATED.load(SeqCst));
}It can also be used directly to allocate memory independently of whatever
global allocator has been selected for a Rust program. For example if a Rust
program opts in to using jemalloc as the global allocator, System will
still allocate memory using malloc and HeapAlloc.
Trait Implementations
Behaves like grow, but also ensures that the new contents are set to zero before being
returned. Read more