Estou modificando a RNNLM como uma rede neural para estudar o modelo de linguagem. No entanto, dado o tamanho do meu corpus, ele está correndo muito devagar. Tentei otimizar a rotina do vetor da matriz * (que é responsável por 63% do tempo total de um pequeno conjunto de dados (eu esperaria que fosse pior em conjuntos maiores)). Agora eu estou preso com intrínsecas.

    for (b=0; b<(to-from)/8; b++) 
    {
        val = _mm256_setzero_ps();
        for (a=from2; a<to2; a++) 
        {
            t1 = _mm256_set1_ps (srcvec.ac[a]);
            t2 = _mm256_load_ps(&(srcmatrix[a+(b*8+from+0)*matrix_width].weight));
            //val =_mm256_fmadd_ps (t1, t2, t3)
            t3 = _mm256_mul_ps(t1,t2);
            val = _mm256_add_ps (val, t3);
        }
        t4 = _mm256_load_ps(&(dest.ac[b*8+from+0]));
        t4 = _mm256_add_ps(t4,val);
        _mm256_store_ps (&(dest.ac[b*8+from+0]), t4);
    }

Este exemplo trava em:

_mm256_store_ps (&(dest.ac[b*8+from+0]), t4);

No entanto, se eu mudar para

_mm256_storeu_ps (&(dest.ac[b*8+from+0]), t4);

(com u para desalinhados, suponho) tudo funciona como pretendido. Minha pergunta é: por quecarga trabalho (embora não deva, se os dados estiverem desalinhados) e o armazenamento não. (além disso, ambos estão operando no mesmo endereço).

dest.ac foram alocados usando

void *_aligned_calloc(size_t nelem, size_t elsize, size_t alignment=64)
{
    size_t max_size = (size_t)-1;

    // Watch out for overflow
    if(elsize == 0 || nelem >= max_size/elsize)
        return NULL;

    size_t size = nelem * elsize;
    void *memory = _mm_malloc(size+64, alignment);
    if(memory != NULL)
        memset(memory, 0, size);
    return memory;
}

e tem pelo menos 50 elementos. (Entre o VS2012, tenho uma instrução ilegal em algumas tarefas aleatórias, então uso o Linux.)

Agradeço antecipadamente, Arkantus.