No way to get mutable reference to Vec member without expressing uniqueness over the full Vec

[orlp]

I've ran into the following standard library defect. There appears to be no possible sound way to go from a Vec<T> to a &mut T without expressing uniqueness over the full Vec. Vec::as_mut_ptr does not suffice because it takes a &mut self which expresses unique access over the full vec. A function which goes from *mut Vec<T> -> *mut T is necessary, but missing. The same is true for *mut [T] -> *mut T.

---

Consider the following example, where I have a v: Vec<Vec<u32>> where m.len() == n and m[i].len() == t for all i. I have t threads and I now want to process this array mutably in parallel, transposed. For example suppose I want to do the following in-place cumulative sum:

(0..t).into_par_iter().map(|thread_idx| {
    let mut cumsum = 0;
    for i in 0..n {
        // This obviously doesn't work, but you can't write this soundly with pointers either.
        let x: &mut u32 = &mut v[i][thread_idx];
        cumsum += *x;
        *x = cumsum;
    }
})

As far as I can tell, there is no way to write this soundly without introducing (potentially significant) overhead at all. The only way to write this soundly is to first create a temporary array of pointers and to modify the inner loop to use those pointers:

let ptrs: Vec<*mut u32> = v.iter_mut().map(|vi| vi.as_mut_ptr()).collect();
    // ...
        let x: &mut u32 = unsafe { &mut *ptrs[i].add(thread_idx) };
}

I really think the standard library should offer some kind of way to write this loop soundly without the unnecessary overhead of creating a pointer array. The simplest solution I think is to add functions which go from *mut Vec<T> -> *mut T and *mut [T] -> *mut T without creating an intermediate unique reference to the entire Vec or slice.

[CodesInChaos]

For slices there is the unstable get_unchecked_mut function (slice_index_methods feature).

For Vec I'd prefer adding a *mut Vec<T> -> *mut [T] function over a *mut Vec<T> -> *mut T function.

[orlp]

Actually what I said about it also being impossible for slices is just not true, even on stable Rust. I forgot that pointer-to-slice is a fat pointer that you can simply cast to a pointer-to-first-element.

I would be fine with a method that goes *mut Vec<T> -> *mut [T], that's probably better.

[ChrisDenton]

Hmm, &mut Vec only asserts uniqueness of the Vec structure itself, no? So it can be sound to get a pointer to the data via as_mut_ptr() and then use that pointer however you like so long as you're careful not to use any Vec functions for the duration (or at least not ones that realloc or create references to the data).

Depending on what you're doing there's also functions like split_at_mut which allows chopping up a mutable slice into separate pieces.

[orlp]

@ChrisDenton No, as_mut_ptr takes &mut self which means it's unsound to call from multiple threads as you're creating a non-unique mutable reference. See the motivating example in the original post.