Implementação de código de Checksum para Neon em Intrinsics
Eu estou tentando implementar o código de computação de soma de verificação (adição de complemento de 2) para NEON, usando intrínseca. O cálculo atual da soma de verificação está sendo executado no ARM.
Minha implementação busca 128-bits de uma vez da memória em registros NEON e faz SIMD (adição), e o resultado é dobrado para um número de 16 bits de um número de 128 bits.
Tudo parece estar funcionando bem, mas a minha implementação NEON está consumindo mais tempo que a versão ARM.
Versão ARM leva:0,860000 s A versão NEON leva:1,260000 s
Nota:
Perfilado usando utilitários de "time.h"A função checksum chamada 10.000 vezes a partir de um aplicativo de amostra, e o tempo computado após a execução completa de todas as funçõesOutros detalhes:
Usado a cadeia de ferramentas GNU (arm-none-linux-gnueabi-gcc) para compilar o código intrínseco e não a cadeia de ferramentas do braço.Plataforma Linux.C-código intrínseco.Questões:
Por que a versão NEON leva mais tempo do que a versão ARM? (Embora eu tenha tomado cuidado para que intrínseco com ciclos mínimos no lote seja usado)
Como conseguir o que eu quero alcançar? (eficiência com NEON)
Alguém poderia apontar para mim ou compartilhar algumas implementações de exemplo (pseudo-código / algoritmos / código, não os papéis teóricos de implementação ou palestras) que usa as inter-operações do ARM-NEON juntas?
Qualquer ajuda seria muito apreciada.
Aqui está meu código:
uint16_t do_csum(const unsigned char * buff, int len)
{
int odd, count, i;
uint32x4_t result = veorq_u32( result, result), sum = veorq_u32( sum, sum);
uint16x4_t data, data_hi, data_low, data8;
uint16x8_t dataq;
uint16_t result16, disp[20] = {0,0,0,0,0,0,0,0,0,0};
if (len <= 0)
goto out;
odd = 1 & (unsigned long) buff;
if (odd) {
uint8x8_t data1 = veor_u8( data1, data1);
data1 = (uint16x4_t)vld1_lane_u8((uint8_t *)buff, data1, 0); //result = *buff << 8;
data1 = (uint16x4_t)vshl_n_u16( data1, 8);
len--;
buff++;
result = vaddw_u16(result, data1);
}
count = len >> 1; /* nr of 16-bit words.. */
if (count) {
if (2 & (unsigned long) buff) {
uint16x4_t data2 = veor_u16( data2, data2);
data2 = (uint16x4_t) vld1_lane_u16((uint16_t *)buff, data2, 0); //result += *(unsigned short *) buff;
count--;
len -= 2;
buff += 2;
result = vaddw_u16( result, data2);
}
count >>= 1; /* nr of 32-bit words.. */
if (count) {
if (4 & (unsigned long) buff) {
uint32x2_t data4 = (uint16x4_t) vld1_lane_u32((uint32_t *) buff, data4, 0);
count--;
len -= 4;
buff += 4;
result = vaddw_u16( result, data4);
}
count >>= 1; /* nr of 64-bit words.. */
if (count) {
if (8 & (unsigned long) buff) {
uint64x1_t data8 = vld1_u64((uint64_t *) buff);
count--;
len -= 8;
buff += 8;
result = vaddw_u16( result,(uint16x4_t)data8);
}
count >>= 1; /* nr of 128-bit words.. */
if (count) {
do {
dataq = (uint16x8_t)vld1q_u64((uint64_t *) buff); // VLD1.64 {d0, d1}, [r0]
count--;
buff += 16;
sum = vpaddlq_u16(dataq);
vst1q_u16( disp, dataq); // VST1.16 {d0, d1}, [r0]
result = vaddq_u32( sum, result);
} while (count);
}
if (len & 8) {
uint64x1_t data8 = vld1_u64((uint64_t *) buff);
buff += 8;
result = vaddw_u16( result, (uint16x4_t)data8);
}
}
if (len & 4) {
uint32x2_t data4 = veor_u32( data4, data4);
data4 = (uint16x4_t)vld1_lane_u32((uint32_t *) buff, data4, 0);//result += *(unsigned int *) buff;
buff += 4;
result = vaddw_u16( result,(uint16x4_t) data4);
}
}
if (len & 2) {
uint16x4_t data2 = veor_u16( data2, data2);
data2 = (uint16x4_t) vld1_lane_u16((uint16_t *)buff, data2, 0); //result += *(unsigned short *) buff;
buff += 2;
result = vaddw_u16( result, data2);
}
}
if (len & 1){
uint8x8_t data1 = veor_u8( data1, data1);
data1 = (uint16x4_t) vld1_lane_u8((uint8_t *)buff, data1, 0); //result = *buff << 8;
result = vaddw_u8( result, data1);
}
result16 = from128to16(result);
if (odd)
result16 = ((result16 >> 8) & 0xff) | ((result16 & 0xff) << 8);
out:
return result16;
}