# Struct std::alloc::System

1.28.0 · source ·

    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. However, it is not valid to mix use of the backing system allocator with `System`, as this implementation may include extra work, such as to serve alignment requests greater than the alignment provided directly by the backing system allocator.

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}");
    }

Run

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::Relaxed};

    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(), Relaxed);
            }
            ret
        }

        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
            System.dealloc(ptr, layout);
            ALLOCATED.fetch_sub(layout.size(), Relaxed);
        }
    }

    #[global_allocator]
    static A: Counter = Counter;

    fn main() {
        println!("allocated bytes before main: {}", ALLOCATED.load(Relaxed));
    }

Run

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§

source§

### impl Allocator for System

source§

#### fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Attempts to allocate a block of memory. Read more
source§

#### fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Behaves like `allocate`, but also ensures that the returned memory is zero-initialized. Read more
source§

#### unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout)

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Deallocates the memory referenced by `ptr`. Read more
source§

#### unsafe fn grow( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout ) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Attempts to extend the memory block. Read more
source§

#### unsafe fn grow_zeroed( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout ) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Behaves like `grow`, but also ensures that the new contents are set to zero before being returned. Read more
source§

#### unsafe fn shrink( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout ) -> Result<NonNull<[u8]>, AllocError>

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Attempts to shrink the memory block. Read more
source§

#### fn by_ref(&self) -> &Self where Self: Sized,

🔬This is a nightly-only experimental API. (`allocator_api` #32838)
Creates a “by reference” adapter for this instance of `Allocator`. Read more
source§

### impl Clone for System

source§

#### fn clone(&self) -> System

Returns a copy of the value. Read more
1.0.0 · source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
source§

### impl Debug for System

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

### impl Default for System

source§

#### fn default() -> System

Returns the “default value” for a type. Read more
source§

### impl GlobalAlloc for System

source§

#### unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocate memory as described by the given `layout`. Read more
source§

#### unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

Behaves like `alloc`, but also ensures that the contents are set to zero before being returned. Read more
source§

#### unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout)

Deallocate the block of memory at the given `ptr` pointer with the given `layout`. Read more
source§

#### unsafe fn realloc( &self, ptr: *mut u8, layout: Layout, new_size: usize ) -> *mut u8

Shrink or grow a block of memory to the given `new_size` in bytes. The block is described by the given `ptr` pointer and `layout`. Read more
source§

### impl Copy for System

## Auto Trait Implementations§

§

### impl RefUnwindSafe for System

§

### impl Send for System

§

### impl Sync for System

§

### impl Unpin for System

§

### impl UnwindSafe for System

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.