Analyse des coûts en EMM et EMW

Pour commencer nous allons analyser le coût de l’algorithme 26 en nombre d’opé- rations. Nous allons nous contenter de compter ici les multiplications élémentaires EMM, comme sont faits habituellement les décomptes de l’état de l’art et comme ce qui a été fait pour le chapitre 3. Dans tous les cas, que ce soit pour notre algorithme ou pour l’état de l’art, les nombres d’EMM et d’EMA sont égaux (ou presque), car les deux algorithmes n’ef- fectuent quasiment que des multiplications suivies d’accumulations. De plus, dans le cas de l’algorithme 26, nous n’allons pas compter les multiplications par 2 que l’on trouve aux lignes 1 et 5 car on peut les voir comme une simple addition.

Les lignes 1, 2 et 5 de l’algorithme SBMM coûtent 4n EMM, qui peuvent être réduites à 3n EMM en utilisant l’astuce de Karatsuba-Ofman [63] pour calculer les lignes 1 et 2. Le choix de l’utilisation de cette astuce dépend de l’architecture implantée, car elle introduit notamment des dépendances de données entre les lignes 1 et 2, alors qu’elles sont indépen- dantes telles qu’écrites dans l’algorithme SBMM. En plus de ces opérations, on effectue deux appels à CSplit. Le coût de CSplit est en fait le même que celui de la fonction Split, en considérant que les 2 premières bases ont le même nombre d’éléments égal à n/2, et que la troisième base n’a aucun élément. On obtient, pour chacun des appels de CSplit, un nombre d’EMM de : na+ na(nb+ nc) + nb+ nbna+ nc = 2  n2 4 + n 2  = n 2 2 + n .

Le coût total de l’algorithme est donc n2_{+ 5n EMM pour effectuer une multiplication mo-} dulo P , contre 2n2_{+ 4n avec l’algorithme de l’état de l’art [48]. Par contre, ce coût ne} prend pas en compte une éventuelle compression des données en sortie. La fonction de compression proposée dans l’algorithme 28 effectue 2 extensions de base de Ba vers mγ

aux lignes 1 et 4, puis 2 multiplications sur mγ aux lignes 2 et 5, et finalement 2 multi- plications sur Bb. Les extensions de base coûtent n/2 EMM sur Ba et n/2 multiplications sur mγ chacune. On compte ici les multiplications modulo mγ à part, car généralement ces multiplications seront sur 5, 6 ou 12 bits alors que les EMM correspondront à des mul- tiplications sur w bits (16 ou 32 par exemple). De plus, une EMM est une multiplication modulo un nombre pseudo-Mersenne, alors que mγ est une puissance de 2 : la réduction modulaire est donc immédiate pour mγ. On notera γEMM ces multiplications modulo mγ. On obtient au total 2n EMM et (n + 2) γEMM. Le coût total de l’algorithme SBMM suivi de la fonction de compression est donc de n2_{+ 7n EMM et (n + 2) γEMM contre 2n}2_{+ 4n EMM dans} l’état de l’art. On a donc divisé par 2, environ, le nombre d’EMM par rapport à l’état de l’art. Nous allons maintenant analyser la parallélisation que propose l’algorithme SBMM et la fonction de compression, car c’est une caractéristique essentielle de la représentation RNS. Dans l’état de l’art, on utilise généralement n unités arithmétiques, par exemple n Rowers, qui correspondent à un élément pour chacune des bases. Dans l’algorithme de l’état de l’art, on utilise uniquement des opérations sur des bases complètes de n moduli, qui se parallélisent donc très bien sur les n Rowers. Notre algorithme 26 calcule, lui, sur les 2 « demi-bases » Ba et Bb de n/2 moduli. Plus précisément, on trouve 2 cas distincts. Soit l’algorithme 26 effectue la même opération sur les deux bases en même temps, comme aux lignes 1, 2 et 5. Dans ce cas, on peut voir Ba|b comme une base complète de n moduli, et paralléliser sur les n Rowers comme d’habitude. Soit, les 2 appels à CSplit, lignes 3 et 4, n’effectuent leurs calculs que sur l’une des 2 demi-bases à la fois. Chacun des CSplit va donc opérer sur seulement n/2 moduli. Ce n’est en réalité pas un problème car les 2 appels à la fonction CSplit sont complètement indépendants : on peut donc les effectuer en parallèle, chacun sur n/2 moduli. Toutes les opérations de l’algorithme 26 sont donc parallélisables sur n Rowers facilement, comme pour l’algorithme de l’état de l’art MM [99] et ses améliorations [6, 48, 64].

La fonction de compression, présentée algorithme 28, est proposée pour une architec- ture où les calculs sur mγ peuvent être effectués en parallèle des calculs sur les bases Baet Bb. Par exemple, en ayant une sorte de petit Rower supplémentaire, calculant modulo 26 ou 212_{. Ainsi, les lignes 2, 5, et les opérations sur m}

γ à l’intérieur des extensions de base sont faites en parallèle des autres calculs sur les 2 bases Ba et Bb. Ensuite, les calculs aux lignes 3 et 6, effectués sur la base Bb, sont complètement indépendants : ils peuvent être effectués en même temps, chacun sur n/2 Rowers. Il en va de même pour les calculs sur Ba effectués par les deux BE aux lignes 1 et 4.

La table 4.2 présente le décompte des pré-calculs pour notre nouvel algorithme. Les pré- calculs du SBMM viennent tous des pré-calculs nécessaires à la fonction CSplit, qui utilise exactement les mêmes astuces que Gandino et al. [48] pour effectuer les extensions de base. Par exemple, les valeurs dans Bb sont multipliées par le pré-calcul

−−−−−→

T_b−1
_b , de la même façon que Gandino et al. ont proposé dans [48]. La différence avec la contribution [48], c’est qu’ici on opère sur des demi-bases, et que nous ne faisons plus les calculs pour la réduction de Montgomery mais pour la fonction de décomposition CSplit. Les n/2 valeurs −−−−−→ T−1 a
a et les n2/4 −−−−−−−−→  −1 ma,iMb,j 

b permettent d’effectuer la première extension de base de CSplit, effectuée à la ligne 1 de l’algorithme CSplit, et permettent d’effectuer en même temps −−−−−→(Rx)b ×

−−−−−−→ M−1

a

b de la ligne 2. Cette contraction d’opérations requiert le stockage de la valeur −−−−−−→_(−Ma)b pour obtenir

−−−−→ (Rx)b , car on obtient −−−−−→(Rx)b × −−−−−−→ M−1 a
b à la sortie

SBMM Compression −−−−−→ T_a−1
_a : n/2 −−−−−−−−−−−→_−Ma× T_b−1
b : n/2 −−−−−−−−→  −1 ma,iMb,j  b : n 2_{/4 |M} a,i|_mγ : n/2* −−−−−−→ _M b,j Ma  b : n/2 |−Ma|mγ : 1* −−−−→ (Tb,i)_a : n2/4  M−1 a   mγ : 1* −−−−−−→ (−Ma)_b : n/2 −−−−−→ T_b−1
_b : n/2 −−−−−−→ (−Mb)_a : n/2 −−−→ (Tb)b : n/2 Total : n2_{/2 + 4n + 2 EMW}

Table 4.2 – Décompte du nombre de pré-calculs à stocker en mots de w bits (EMW) de notre algorithme SPRR. Note * : les valeurs notées * sont en réalité plus petites que w bits.

Algorithme coût en multiplications coût en mémoire pré-calculée

MM 2n2+ 4n EMM 2n2+ 10n EMW

SBMM n2+ 5n EMM n₂2 + 3n EMW

SBMM+ compression (n2_{+ 7n) EMM + (n + 2) γEMM} n2

2 + 4n + 2 EMW ÷4 ÷2

Table4.3 – Comparaison du nombre de multiplications élémentaires et du nombre de mots mémoire élémentaires à stocker pour les algorithmes MM et SBMM, avec et sans compression des sorties.

de la première extension de base. Le vecteur −−−−−−→Mb,j

Ma  b permet d’effectuer −→ Xb ×−−−−−−→Ma−1
b .

Les valeurs −−−−→(Tb,i)_a et −−−−−−→(−Mb)a sont utilisées pour la deuxième extension de base de la fonction CSplit. Pour la compression, −−−−−−−−−−−→_−Ma× T_b−1
_b sert à calculer(R−−−→k)b et−−−→(Rr)b aux lignes 3 et 6 de l’algorithme 28. Si on stocke −−−−−−−−−−−→_−Ma× T_b−1
_b plutôt que −−−−−−→(−Ma)b , c’est parce que dans la seconde demi-base Bb, les valeurs sont toutes multipliées par

−−−−−→ T_b−1
_b car on utilise la représentation de Gandino et al. [48]. Ensuite, les n/2 valeurs |Ma,i|_mγ sont nécessaires pour calculer le CRT modulo mγ, et |−Ma|_mγ permet de corriger le calcul du CRT avec l’astuce de Kawamura et al. [64]. Enfin, M−1

a  

mγ permet de calculer Kk et Kr dans l’algorithme 28. La table 4.3 résume et compare les coûts en calcul et en mémoire entre l’algorithme de l’état de l’art MM et l’algorithme SBMM, avec et sans compression des sorties de celui-ci.