Ich versuche, den Prüfsummen-Berechnungscode (Zweierkomplement-Addition) für NEON mit intrinsic zu implementieren. Die aktuelle Prüfsummenberechnung wird auf ARM ausgeführt.

Meine Implementierung holt 128-Bit auf einmal aus dem Speicher in NEON-Register und führt SIMD (Addition) aus, und das Ergebnis wird von einer 128-Bit-Zahl auf eine 16-Bit-Zahl gefaltet.

Alles scheint gut zu funktionieren, aber meine NEON-Implementierung kostet mehr Zeit als die ARM-Version.

ARM-Version dauert:0,860000 s NEON-Version dauert:1,260000 s

Hinweis:

Profilerstellung mit Dienstprogrammen von "time.h"Die Prüfsummenfunktion wurde 10.000 Mal von einer Beispielanwendung aufgerufen und die Zeit nach dem vollständigen Ausführen aller Funktionen berechnet

Andere Details:

Verwendete GNU-Toolkette (arm-none-linux-gnueabi-gcc) zum Kompilieren des eigentlichen Codes und nicht arm-Toolkette.Linux-Plattform.C-Eigencode.

Fragen:

Warum benötigt die NEON-Version mehr Zeit als die ARM-Version? (Obwohl ich darauf geachtet habe, dass in der Charge intrinsisch mit minimalen Zyklen gearbeitet wird)

Wie erreiche ich, was ich erreichen will? (Effizienz mit NEON)

Könnte jemand auf mich hinweisen oder einige Beispielimplementierungen (Pseudocode / Algorithmen / Code, nicht die theoretischen Implementierungspapiere oder -gespräche) teilen, die die Interaktionen von ARM-NEON zusammen verwenden?

Jede Hilfe wäre sehr dankbar.

Hier ist mein Code:

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;
}