Can I reset a borrow of a local in a loop?

Question

I have a processing loop that needs a pointer to a large lookup table. The pointer is unfortunately triply indirected from the source data, so keeping that pointer around for the inner loop is essential for performance.

Is there any way I can tell the borrow checker that I'm "unborrowing" the state variable in the unlikely event I need to modify the state... so I can only re-lookup the slice in the event that the modify_state function triggers?

One solution I thought of was to change data to be a slice reference and do a mem::replace on the struct at the beginning of the function and pull the slice into local scope, then replace it back at the end of the function — but that is very brittle and error prone (as I need to remember to replace the item on every return). Is there another way to accomplish this?

struct DoubleIndirect {
    data: [u8; 512 * 512],
    lut: [usize; 16384],
    lut_index: usize,
}

#[cold]
fn modify_state(s: &mut DoubleIndirect) {
    s.lut_index += 63;
    s.lut_index %= 16384;
}

fn process(state: &mut DoubleIndirect) -> [u8; 65536] {
    let mut ret: [u8; 65536] = [0; 65536];
    let mut count = 0;
    let mut data_slice = &state.data[state.lut[state.lut_index]..];
    for ret_item in ret.iter_mut() {
        *ret_item = data_slice[count];
        if count % 197 == 196 {
            data_slice = &[];
            modify_state(state);
            data_slice = &state.data[state.lut[state.lut_index]..];
        }
        count += 1
    }
    return ret;
}

Answer 1

The simplest way to do this is to ensure the borrows of state are all disjoint:

#[cold]
fn modify_state(lut_index: &mut usize) {
    *lut_index += 63;
    *lut_index %= 16384;
}

fn process(state: &mut DoubleIndirect) -> [u8; 65536] {
    let mut ret: [u8; 65536] = [0; 65536];
    let mut count = 0;
    let mut lut_index = &mut state.lut_index;
    let mut data_slice = &state.data[state.lut[*lut_index]..];
    for ret_item in ret.iter_mut() {
        *ret_item = data_slice[count];
        if count % 197 == 196 {
            modify_state(lut_index);
            data_slice = &state.data[state.lut[*lut_index]..];
        }
        count += 1
    }
    return ret;
}

The problem is basically two things: first, Rust will not look beyond a function's signature to find out what it does. As far as the compiler knows, your call to modify_state could be changing state.data as well, and it can't allow that.

The second problem is that borrows are lexical; the compiler looks at the block of code where the borrow might be used as goes with that. It doesn't (currently) bother to try and reduce the length of borrows to match where they're actually active.

You can also play games with, for example, using std::mem::replace to pull state.data out into a local variable, do your work, then replace it back just before you return.