Optimisation de __mm_add_epi32_inplace_purego à l'aide de Assembly

Cette question cherche à optimiser la boucle interne de la fonction __mm_add_epi32_inplace_purego, qui effectue un décompte de population positionnelle sur un tableau d'octets. L'objectif est d'améliorer les performances en utilisant les instructions d'assemblage.

L'implémentation Go originale de la boucle interne :

    __mm_add_epi32_inplace_purego(&counts[i], expand)

Le l'utilisation de '&counts[i]' pour transmettre l'adresse d'un élément du tableau peut être inefficace. Pour optimiser cela, nous pouvons plutôt passer le pointeur sur l'ensemble du tableau :

__mm_add_epi32_inplace_inplace_purego(counts, expand)

Cette modification réduit la surcharge associée au passage de tableaux en tant qu'arguments.

De plus, la boucle intérieure peut être optimisée davantage à l'aide des instructions de montage. Le code assembleur suivant est une version de __mm_add_epi32_inplace_purego implémentée dans assembly :

// 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

Ce code assembleur charge les éléments de 'counts' et 'expand' dans des registres, effectue l'addition et stocke le résultat dans 'counts'. En évitant de passer des tableaux en arguments et en utilisant des instructions d'assemblage efficaces, ce code améliore considérablement les performances de la boucle interne.

En résumé, en passant le pointeur vers le tableau au lieu de l'adresse d'un élément et en implémentant la boucle interne dans l'assemblage, la fonction __mm_add_epi32_inplace_purego peut être optimisée pour obtenir des performances améliorées dans les opérations de comptage de population positionnelle.