Memory-Efficient State Machines

In this lesson, you will learn how to design compact, enum-based state machines that minimize memory footprint by leveraging Rust’s data-layout optimizations.

The Problem of "Fat" States

When building a state machine, a common mistake is to store all possible state data in one large struct. If your state machine can be Idle, Processing(Data), or Error(String), a struct containing all these fields will always occupy the memory of the largest variant, even when the machine is Idle. This is inefficient in memory-constrained systems.

The Enum Advantage

Rust enum variants are designed to be memory-efficient. When you define an enum, the compiler creates a layout that only occupies enough space to hold the largest variant plus a small "tag" to identify the current state.

// This enum is only as large as its biggest variant (Data + tag)
enum SystemState {
    Idle,
    Processing { buffer: [u8; 1024] },
    Error(u32),
}

Minimizing Overhead

To ensure these state machines remain memory-efficient, keep your variants "slim." If one state requires a large buffer while others are simple, consider boxing the large data or using specialized memory layouts (like #[repr(u8)] if you have very few states) to keep the discriminant tag small.

When transitioning between states, you should use std::mem::replace or take to transition the state without cloning data. This allows you to move ownership of the data from the old state into the new state in-place:

fn transition(current: &mut SystemState) {
    match std::mem::replace(current, SystemState::Idle) {
        SystemState::Processing { buffer } => {
            // Move the buffer to the next state, zero allocation overhead
            *current = SystemState::Error(0);
        }
        _ => {}
    }
}

By utilizing mem::replace, we ensure that we aren't creating temporary copies of our data during the transition, keeping the stack usage predictable and the memory footprint at an absolute minimum. Because the compiler knows the size of the enum at compile time, it can generate machine code that simply updates the discriminant and performs a shallow bitwise copy of the internal data, fulfilling our requirement for low-latency, high-efficiency state transitions.

Key Takeaway: Use enums to store only the data relevant to the current state, and use std::mem::replace to perform zero-allocation state transitions.