How to go not out of bounds when loading data from the end of an array into AVX/AVX2 registers?

If I know I have e.g. at least 4 doubles sitting at given (aligned) location in memory,
double *d, I can simply do __m256d x = _mm256_load_pd(&d[i]), i.e. load them into an AVX(2) register.

The question is: How do I correctly handle cases where there aren't 4 doubles left at the given location, i.e. I'd theoretically access the array out of bounds?

One solution that I have been using so far is to only allocate memory of multiples of 4 * 8 bytes in this specific case. Alternatively, for cases where I do not control the memory allocation completely, I have also been playing with stuff like this, assuming that this probably not the way to go:

static __m256d inline _load_256d(size_t diff, size_t i, double *d){

    if (diff == 4) {
        return _mm256_load_pd(&d[i]);
    }
    if (diff == 3) {
        return _mm256_set_pd(0.0, d[i+2], d[i+1], d[i]);
    }
    if (diff == 2) {
        return _mm256_set_pd(0.0, 0.0, d[i+1], d[i]);
    }
    return _mm256_set_pd(0.0, 0.0, 0.0, d[i]);

}

What is the (a) canonical solution for a case like this?

For reads, and assuming the start of the overall vector is aligned, one simply reads the entire SIMD block and ignores the undesired elements. The hardware design is such that if the first byte of a block is readable, all bytes of the block are readable (because the pages used to map and protect memory are aligned to boundaries at least as large as the SIMD block alignments).

For writes, there is no canonical answer; there are multiple options depending on circumstances, including:

• Require the calling software to provide padding so that whole-block stores can always be performed even if only one element is used in the last block.
• Use an instruction that stores with a mask to specify which elements are updated.
• Write code separate from the main loop to handle the last block using instructions for scalar elements or partial blocks (e.g., 16-byte SIMD instructions instead of 32-byte instructions).
• Use an unaligned store to store a whole block that ends where the destination vector ends. This will overlap elements in the prior block, so they can either be stored twice (if the computation permits) or merged (load, permute as necessary, store). (This also requires taking care to handle the case where the entire vector is less than a full block.)
• If the application is single-threaded (so it is known no other code that could be writing to the same block is executing), read the last block, merge in the changed elements, and write the last block.