Optimieren von __mm_add_epi32_inplace_purego mithilfe von Assembly

Diese Frage zielt darauf ab, die innere Schleife der Funktion __mm_add_epi32_inplace_purego zu optimieren, die eine Positionsbelegungszählung für ein Array von Bytes durchführt. Das Ziel besteht darin, die Leistung durch die Verwendung von Montageanweisungen zu verbessern.

Die ursprüngliche Go-Implementierung der inneren Schleife:

    __mm_add_epi32_inplace_purego(&counts[i], expand)

The Die Verwendung von „&counts[i]“ zur Übergabe der Adresse eines Array-Elements kann ineffizient sein. Um dies zu optimieren, können wir stattdessen den Zeiger auf das gesamte Array übergeben:

__mm_add_epi32_inplace_inplace_purego(counts, expand)

Diese Änderung reduziert den Overhead, der mit der Übergabe von Arrays als Argumente verbunden ist.

Zusätzlich kann die Innenschlaufe mithilfe einer Montageanleitung noch weiter optimiert werden. Der folgende Assemblycode ist eine in Assembly implementierte Version von __mm_add_epi32_inplace_purego:

// func __mm_add_epi32_inplace_asm(counts *[8]int32, expand *[8]int32)
TEXT ·__mm_add_epi32_inplace_asm(SB),NOSPLIT,$0-16
    MOVQ counts 0(FP), DI
    MOVQ expand 8(FP), SI
    MOVL 8*0(DI), AX        // load counts[0]
    ADDL 8*0(SI), AX        // add expand[0]
    MOVL AX, 8*0(DI)        // store result in counts[0]
    MOVL 8*1(DI), AX        // load counts[1]
    ADDL 8*1(SI), AX        // add expand[1]
    MOVL AX, 8*1(DI)        // store result in counts[1]
    MOVL 8*2(DI), AX        // load counts[2]
    ADDL 8*2(SI), AX        // add expand[2]
    MOVL AX, 8*2(DI)        // store result in counts[2]
    MOVL 8*3(DI), AX        // load counts[3]
    ADDL 8*3(SI), AX        // add expand[3]
    MOVL AX, 8*3(DI)        // store result in counts[3]
    MOVL 8*4(DI), AX        // load counts[4]
    ADDL 8*4(SI), AX        // add expand[4]
    MOVL AX, 8*4(DI)        // store result in counts[4]
    MOVL 8*5(DI), AX        // load counts[5]
    ADDL 8*5(SI), AX        // add expand[5]
    MOVL AX, 8*5(DI)        // store result in counts[5]
    MOVL 8*6(DI), AX        // load counts[6]
    ADDL 8*6(SI), AX        // add expand[6]
    MOVL AX, 8*6(DI)        // store result in counts[6]
    MOVL 8*7(DI), AX        // load counts[7]
    ADDL 8*7(SI), AX        // add expand[7]
    MOVL AX, 8*7(DI)        // store result in counts[7]
    RET

Dieser Assemblercode lädt die Elemente von „counts“ und „expand“ in Register, führt die Addition durch und speichert das Ergebnis zurück in „counts“. Durch die Vermeidung der Notwendigkeit, Arrays als Argumente zu übergeben, und durch die Verwendung effizienter Assembleranweisungen verbessert dieser Code die Leistung der inneren Schleife erheblich.

Zusammenfassend lässt sich sagen, dass der Zeiger auf das Array anstelle der Adresse eines Elements übergeben wird und durch die Implementierung der inneren Schleife in Assembly kann die Funktion __mm_add_epi32_inplace_purego optimiert werden, um eine verbesserte Leistung bei Positionszählungsoperationen für Populationen zu erzielen.