Struct Memory

pub struct Memory<T> { /* private fields */ }

Something being budgeted.

See with.

Implementations

impl<T> Memory<T>

where T: Callable,

pub fn call(self) -> T::Output

Call the wrapped function, replacing the current budget and restoring it once the function call completes.

Examples

use rune::alloc::limit;
use rune::alloc::{Box, Result};
use rune::alloc::alloc::AllocError;

const LIMIT: usize = 1024;

fn doit() -> Result<Box<[u8; 256]>, AllocError> {
    Box::try_new([0u8; 256])
}

fn limited() -> Result<()> {
    assert_eq!(limit::get(), LIMIT);

    // Hold onto a 256 byte allocation.
    let b = doit()?;
    assert_eq!(limit::get(), LIMIT - 256);

    // Drop the allocation, making the memory available again.
    drop(b);
    assert_eq!(limit::get(), LIMIT);
    Ok(())
}

let inner = limit::with(LIMIT, limited);

assert_eq!(limit::get(), usize::MAX);
inner.call()?;
assert_eq!(limit::get(), usize::MAX);

Limit being restored after its been breached:

use rune::alloc::limit;
use rune::alloc::{Box, Result};
use rune::alloc::alloc::AllocError;

const LIMIT: usize = 128;

fn doit() -> Result<Box<[u8; 256]>, AllocError> {
    Box::try_new([0u8; 256])
}

fn limited() -> Result<()> {
    assert_eq!(limit::get(), LIMIT);

    // Fail to allocate since we don't have enough memory available.
    assert!(doit().is_err());

    assert_eq!(limit::get(), LIMIT);
    Ok(())
}

let inner = limit::with(LIMIT, limited);

assert_eq!(limit::get(), usize::MAX);
inner.call()?;
assert_eq!(limit::get(), usize::MAX);

Trait Implementations

impl<T> Callable for Memory<T>

where T: Callable,

type Output = <T as Callable>::Output

Output of the callable.

fn call(self) -> Self::Output

Call and consume the callable.

impl<T> Future for Memory<T>

where T: Future,

Treat the current budget as a future, ensuring that the budget is suspended and restored as necessary when the future is being polled.

Examples

use rune::alloc::limit;
use rune::alloc::{Box, Result};
use rune::alloc::alloc::AllocError;

const LIMIT: usize = 1024;

async fn doit() -> Result<Box<[u8; 256]>, AllocError> {
    Box::try_new([0u8; 256])
}

async fn limited() -> Result<()> {
    assert_eq!(limit::get(), LIMIT);

    // Hold onto a 256 byte allocation.
    let b = doit().await?;
    assert_eq!(limit::get(), LIMIT - 256);

    // Drop the allocation, making the memory available again.
    drop(b);
    assert_eq!(limit::get(), LIMIT);
    Ok(())
}

let inner = limit::with(LIMIT, limited());

assert_eq!(limit::get(), usize::MAX);
inner.await?;
assert_eq!(limit::get(), usize::MAX);

Limit being restored after its been breached:

use rune::alloc::limit;
use rune::alloc::{Box, Result};
use rune::alloc::alloc::AllocError;

const LIMIT: usize = 128;

async fn doit() -> Result<Box<[u8; 256]>, AllocError> {
    Box::try_new([0u8; 256])
}

async fn limited() -> Result<()> {
    assert_eq!(limit::get(), LIMIT);

    // Fail to allocate since we don't have enough memory available.
    assert!(doit().await.is_err());

    assert_eq!(limit::get(), LIMIT);
    Ok(())
}

let inner = limit::with(LIMIT, limited());

assert_eq!(limit::get(), usize::MAX);
inner.await?;
assert_eq!(limit::get(), usize::MAX);

type Output = <T as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'pin, T> Unpin for Memory<T>

where PinnedFieldsOf<__Memory<'pin, T>>: Unpin,