Pinned Memory for Async State Machines

Snippet

Pinned Memory for Async State Machines

The 'Pin' wrapper ensures that a value stays at a fixed memory address. This is critical for self-referential structs where a field stores a pointer to another field within the same object. If the object moved, the internal pointer would become dangling.

snippet.rs
rust
use std::pin::Pin;
use std::marker::PhantomPinned;
 
struct SelfReferential {
    data: String,
    ptr: *const String,
    _pin: PhantomPinned,
}
 
impl SelfReferential {
    pub fn new(data: String) -> Pin<Box<Self>> {
        let res = SelfReferential {
            data,
            ptr: std::ptr::null(),
            _pin: PhantomPinned,
        };
        let mut boxed = Box::pin(res);
        let self_ptr: *const String = &boxed.data;
        unsafe {
            let mut_ref: Pin<&mut Self> = boxed.as_mut();
            Pin::get_unchecked_mut(mut_ref).ptr = self_ptr;
        }
        boxed
    }
}

Breakdown

_pin: PhantomPinned,

A marker to inform the compiler that this type does not implement the Unpin trait.

let mut boxed = Box::pin(res);

Allocates the struct on the heap and pins it, preventing it from being moved.

Previous snippet Next snippet

From your library

Pinned Memory for Async State Machines

Related