La¸co de Miller

4.3 Contagem de Opera¸c˜ oes

4.3.1 La¸co de Miller

Esta se¸cão apresentará a contagem do número total de opera¸cões no la¸co de Miller dos emparelhamentos: Optimal Ate (Algoritmo 3.5), R-Ate (Algoritmo 3.4) e Ate (Algoritmo 3.2) configurados de acordo com as descri¸cões da Se¸cão 4.2.1.

A nota¸cão “Pré-comp.” representa a pré computa¸cão de dados utilizados para simplificar a aritmética sobre as curvas, como descrito na Se¸cão 4.2.2.

Tabela 4.2: Custo das opera¸cões básicas utilizadas no cálculo dos emparelhamentos bilineares.

E0_(Fp2)

Opera¸c˜oes Custo

Duplica¸c˜ao (Afins) 3 ˜mu+ 2 ˜su+ 7˜a + ˜i + 5˜r + 4m

Soma (Afins) 3 ˜mu+ ˜su+ 6˜a + ˜i + 4˜r + 4m

Duplica¸cão (Proj.) 3 ˜mu+ 6 ˜su+ 16ã + 8˜r + 4m Soma (Proj.) 11 ˜mu+ 2 ˜su+ 8ã + 11˜r + 4m Nega¸cão a˜ p-potência 2 ˜mu+ 2a p2_-potˆ_encia _2m u+ ã Pré-comp. (Afins) i + m + a Pré-comp. (Proj.) 4a Fp12 Opera¸cão Custo Adi¸cão 6ã Multiplica¸cão 18 ˜mu + 103ã + 6˜r Quadrado 12 ˜mu + 6 ˜su+ 65ã + 6˜r

Mult. 1-esparsa (Afins) 10 ˜mu+ 29˜a + 6˜r

Mult. 2-esparsa (Afins) (Opt. Ate) 3 ˜mu + 10˜a + 5˜r

Mult. 1-esparsa (Proj.) 16 ˜mu+ 31˜a + 6˜r

Mult. 2-esparsa (Proj.) (Opt. Ate) 6 ˜mu + 21˜a + 5˜r

Conjuga¸c˜ao 3˜a

p-potˆencia 5 ˜m + 6a p2_-potˆ_encia _{10m + 2˜}_a

p3_-potˆ_encia _{5 ˜}_{m + 2˜}_{a + 6a}

Invers˜ao 28 ˜mu+ 9 ˜su+ 102˜a + 16˜r + ˜i

Emparelhamento Optimal Ate

N◦ de opera¸cões = (pré-comp.) + 64(duplica¸cões de pontos) + 6(somas de pontos) + 2(mult. 2-esparsa) + 63(quadrados em Fp12) + 66(mult. 1-esparsa) + 1(p−potência em E0(F_p2)) +

1(p2−potˆencia em E0

(Fp2)) + 2(nega¸c˜oes em E0(F_p2)) + 1(conjuga¸c˜ao em F_p12) + 1(multipli-

ca¸c˜_{ao em F}p12).

Coordenadas Afins:

Custo = (i + mu+ a) + 64(3 ˜mu+ 2 ˜su+ 7˜a + ˜i + 5˜r + 4mu) + 6(3 ˜mu+ ˜su+ 6˜a + ˜i + 4˜r + 4mu) +

2(3 ˜mu+ 10ã + 5˜r) + 63(12 ˜mu+ 6 ˜su+ 65ã + 6˜r) + 66(10 ˜mu+ 29ã + 6˜r) + (2 ˜mu+ 2a) + (2mu+ ˜ a) + (2ã) + (3ã) + (18 ˜mu+ 103ã + 6˜r) Custo = 1652 ˜mu+ 512 ˜su+ 6622ã + 70˜i + 1134˜r + 283mu+ 3a + i = 5891mu+ 1164su+ 28721a + 6736r + 71i Coordenadas Projetivas: Custo = (4a) + 64(3 ˜mu+ 6 ˜su+ 16ã + 8˜r + 4mu) + 6(11 ˜mu+ 2 ˜su+ 8ã + 11˜r + 4mu) + 2(6 ˜mu+ 21ã + 5˜r) + 63(12 ˜mu+ 6 ˜su+ 65ã + 6˜r) + 66(16 ˜mu+ 31ã + 6˜r) + (2 ˜mu+ 2a) + (2mu+ ã) + (2ã) + (3ã) + (18 ˜mu+ 103ã + 6˜r) Custo = 2102 ˜mu+ 774 ˜su+ 7364ã + 1368˜r + 282m + 6a = 7362mu+ 1548su+ 34646a + 8488r Emparelhamento R-Ate

N◦ de opera¸cões = (pré-comp.) + 63(duplica¸cões de pontos) + 6(somas de pontos) + 62(quadrados em Fp12) + 68(mult. 1-esparsa) + 1(p−potência em E0(F_p2)) + 1(p−potência em F_p12) +

1(multiplica¸c˜_{ao em F}p12).

Coordenadas Afins:

62(12 ˜mu+ 6 ˜su+ 65ã + 6˜r) + 68(10 ˜mu+ 29ã + 6˜r) + (2 ˜mu+ 2a) + (5 ˜mu+ 6a) + (18 ˜mu+ 103ã + 6˜r) Custo = 1656 ˜mu+ 504 ˜su+ 6582ã + 1125˜r + 69˜i + 277m + 9a + i = 5887mu+ 1146su+ 28644a + 6708r + 70i Coordenadas Projetivas: Custo = (4a) + 63(3 ˜mu+ 6 ˜su+ 16ã + 8˜r + 4mu) + 6(11 ˜mu+ 2 ˜su+ 8ã + 11˜r + 4mu) + 62(12 ˜mu+ 6 ˜su+ 65ã + 6˜r) + 68(16 ˜mu + 31ã + 6˜r) + (2 ˜mu+ 2a) + (5 ˜mu+ 6a) + (18 ˜mu+ 103ã + 6˜r) Custo = 2112 ˜mu+ 762 ˜su+ 7297ã + 1356˜r + 276m + 12a = 7374mu+ 1524su+ 34550a + 8460r Emparelhamento Ate

N◦ de opera¸c˜oes = (pr´_{e-comp.) + 124(quadrados em F}p12) + 125(duplica¸c˜oes de pontos) +

134(mult. 1-esparsa) + 10(somas de pontos).

Coordenadas Afins:

Custo = (i + mu+ a) + 125(3 ˜mu + 2 ˜su+ 7˜a + ˜i + 5˜r + 4mu) + 10(3 ˜mu + ˜su + 6˜a + ˜i + 4˜r +

4mu) + 124(12 ˜mu+ 6 ˜su+ 65˜a + 6˜r) + 134(10 ˜mu+ 29˜a + 6˜r)

Custo = 3233 ˜mu+ 1004 ˜su+ 12881˜a + 135˜i + 2213˜r + 541mu+ i + a

Tabela 4.3: Custo de c´alculo dos emparelhamentos bilineares para coordenadas afins. Optimal Ate

Loop de Miller 5891mu+ 1164su+ 28721a + 6736r + 71i

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 8256mu+ 3512su+ 52503a + 11714r + 75i

R-Ate

Loop de Miller 5887mu+ 1146su+ 28644a + 6708r + 70i

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 8252mu+ 3494su+ 52426a + 11696r + 74i

Ate

Loop de Miller 11514mu+ 2278su+ 56048a + 13170r + 136i

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 13879mu+ 4626su+ 79830a + 18158r + 140i

Coordenadas Projetivas:

Custo = (4a) + 125(3 ˜mu+ 6 ˜su+ 16˜a + 8˜r + 4m) + 10(11 ˜mu+ 2 ˜su+ 8˜a + 11˜r + 4m) + 124(12 ˜mu+

6 ˜su+ 65˜a + 6˜r) + 134(16 ˜mu+ 31˜a + 6˜r)

Custo = 4117 ˜mu+ 1514 ˜su+ 14294˜a + 2658˜r + 540m + 4a

= 14404mu+ 3028su+ 67584a + 16578r

As Tabelas 4.3 e 4.4 sintetizam as informa¸cões apresentadas até este ponto sobre o custo de execu¸cão de cada emparelhamento para coordenadas afins e projetivas.

Tanto em coordenadas afins como projetivas o emparelhamento R-Ate apresentou um custo total ligeiramente inferior ao custo do emparelhamento Optimal Ate, principalmente nas oper- a¸cões de maior impacto, que são multiplica¸cões, quadrados, redu¸cões e inversões. Em coordenadas projetivas homogêneas, o emparelhamento Optimal Ate apresentou custo inferior ao do emparelhamento R-Ate apenas no número de multiplica¸c˜_{oes sobre F}p. Porém, em rela¸cão às

demais opera¸cões o Optimal Ate demonstrou custo superior ao do R-Ate. O emparelhamento Ate não foi considerado nas compara¸cões anteriores, devido ao seu custo superior aos demais em ambos os tipos de coordenadas.

Pelas an´alises do n´umero de opera¸c˜_{oes sobre F}p dos emparelhamentos Ate, R-Ate e Optimal

Tabela 4.4: Custo de c´alculo dos emparelhamentos bilineares para coordenadas projetivas. Optimal Ate

Loop de Miller 7362mu+ 1548su+ 34646a + 8488r

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 9727mu+ 3896su+ 58428a + 13476r + 4i

R-Ate

Loop de Miller 7374mu+ 1524su+ 34550a + 8460r

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 9739mu+ 3872su+ 58332a + 13448r + 4i

Ate

Loop de Miller 14404mu+ 3028su+ 67584a + 16578r

Exp. Final 2365mu+ 2348su+ 23782a + 4988r + 4i

Custo total 16769mu+ 5376su+ 91366a + 21566r + 4i

Fp quando comparado aos demais tipos de emparelhamentos. At´e este ponto ´e dif´ıcil efetuar

uma compara¸cão mais detalhada destes emparelhamentos, pois, é necessário descrever o custo computacional dos mesmos em fun¸cão de uma determinada implementa¸cão, o que será feito no cap´ıtulo seguinte. Novamente, vale a pena frisar que estes resultados se restringem à escolha de parâmetros pré-determinados para esta análise, podendo ser diferentes em outras condi¸cões.

4.3.2 Conclus˜oes

Este cap´ıtulo descreveu o esquema de representa¸cão de extensões de corpos finitos via uti- liza¸cão de extensões em torre, que é uma forma eficiente de realizar opera¸cões aritméticas sobre corpos finitos com grau de extensão alto. Apresentou a técnica de lazy reduction, uma forma de postergar redu¸cões modulares aumentando a eficiência das opera¸cões aritméticas sobre os corpos finitos. Descreveu como executar opera¸cões de adi¸cão e soma de pontos em curvas el´ıp- ticas utilizando fun¸cões de linha, que diminui o custo do la¸co de Miller. Descreveu uma forma eficiente de realizar a opera¸cão de exponencia¸cão final, utilizando aritmética sobre subcorpos ciclotômicos. Finalizando, descreveu todas as opera¸cões presentes no cálculo dos emparelhamentos Optimal Ate, R-Ate e Ate, utilizando coordenadas afins e projetivas, para que fosse poss´ıvel executar uma compara¸cão destes emparelhamentos em determinada condi¸cão. Como resultado desta compara¸cão constatou-se que há condi¸cões nas quais o emparelhamento R-Ate se mostra mais eficiente que os demais. No próximo cap´ıtulo será dada continua¸cão a esta compara¸cão, porém no n´ıvel zero da Figura 2.1 com base em uma arquitetura genérica.

Cap´ıtulo

5

An´alise de Custo de Emparelhamentos

Bilineares no N´ıvel de Opera¸c˜oes de Processador

No cap´ıtulo anterior, foi estimado o custo de cálculo dos emparelhamentos Optimal Ate, R-Ate e Ate no n´ıvel de opera¸cões de adi¸cão, multiplica¸cão, quadrado, inverso multiplicativo e redu¸c˜_{oes modulares sobre F}p.

Neste cap´ıtulo será estimado o custo de cada uma destas opera¸cões no n´ıvel de processador, o n´ıvel mais baixo de implementa¸cão (n´ıvel zero da Fig. 2.1). Com esta análise, será poss´ıvel estimar o impacto causado por diferentes arquiteturas de processadores genéricos no cálculo dos emparelhamentos bilineares.

Os custos das opera¸cões de adi¸cão, multiplica¸cão, quadrado, redu¸cões modulares e inverso multiplicativo sobre Fp serão descritos em fun¸cão do número de opera¸cões de adi¸cão e mul-

tiplica¸cão nativas do processador. Nestas análises, serão adotadas as nota¸cões a0 e m0 para representar tais opera¸cões de adi¸cão e multiplica¸cão de inteiros de tamanho w, respectivamente, onde w representa o tamanho da palavra do processador.

Nas análises das opera¸cões de adi¸cão, multiplica¸cão, quadrado, redu¸cão modular e inversão sobre Fp que serão apresentadas no decorrer deste cap´ıtulo são considerados os custos de trans-

ferência de operandos entre a memória e o processador, de opera¸cões aritméticas nativas do processador (adi¸cão e multiplica¸cão de operandos do tamanho da palavra do processador) e de opera¸cões lógicas.

5.1 Algoritmo de Adi¸c˜_{ao em F}

Exemplo 5.1 Considere o método de adi¸cão lápis-e-papel (a forma mais simples de efetuar adi¸cões) para efetuar a soma de dois números binários, X = 11101 e Y = 11011. A adi¸cão binária é efetuada como ilustrado na Fig. 5.1. Observe que cada bit xi de X é somado com o

bit yi de posi¸c˜ao correspondente em Y e com o bit excedente da soma anterior (carry).

Figura 5.1: Adi¸c˜ao bin´aria.

O m´etodo apresentado no Exemplo 5.1 pode ser generalizado para soma de inteiros que ocupam v´_{arias palavras. Considere a soma de dois inteiros X, Y ∈ F}p em um processador

com palavra de tamanho w bits. O tamanho destes inteiros é de n = dlog₂pe bits. Logo, independente do valor de X e Y , serão reservadas W palavras para armazenar cada um, onde W = _wn. De forma similar ao método lápis-e-papel (Exemplo 5.1), cada palavra Xi será

somada com uma palavra Yi da posi¸c˜ao correspondente. O inteiro Z = X + Y ´e representado

por W palavras mais um poss´ıvel bit de carry.

Para melhor exemplificar, considere um caso particular onde X e Y sejam representados com 4 palavras de w bits e o resultado da soma de X e Y também seja representado dessa mesma forma. A Fig. 5.2 mostra como a adi¸cão de X e Y é executada.

Figura 5.2: Adi¸c˜ao de inteiros com 4 palavras.

Z0 = X0+ Y0

Z1 = X1+ Y1+ CZ0

Z2 = X2+ Y2+ CZ1

Z3 = X3+ Y3+ CZ2

Para efetuar as somas e obter os valores Z0, Z1, Z2 e Z3 ser´a considerado que o processador

em questão possua dois tipos de instru¸cão de adi¸cão: ADD e ADDC. A instru¸cão ADD efetua a soma de dois operandos de w bits (ex: X0 + Y0). A instru¸cão ADDC efetua a soma de

dois operandos de w bits e soma o resultado com o carry gerado pela opera¸c˜ao anterior (ex: X1+ Y1+ CZ0). As sintaxes de todas as instru¸c˜oes dos processadores considerados neste cap´ıtulo

estão documentadas no Apêndice A.1. Também será considerado que o custo de execu¸cão da instru¸cão ADDC é equivalente ao custo de execu¸cão da instru¸cão ADD.

A partir do cálculo de Z1 deve ser utilizado a instru¸cão de soma ADDC ao invés da instru¸cão

ADD, pelo fato existir um poss´ıvel carry resultante da soma dos blocos X0 e Y0, Ap´os obter

Z = X + Y , deve ser verificado se Z ∈ Fp. Caso Z 6∈ Fp deve ser executada uma redu¸c˜ao m´odulo

p (Z mod p), a qual pode ser efetuada com uma opera¸cão de subtra¸cão Z − p envolvendo dois operandos de W palavras. Considere que, para efetuar esta subtra¸cão o processador em questão possua dois tipos de instru¸cões de subtra¸cão: SUB e SUBC. A instru¸cão SUB efetua a subtra¸cão de dois operandos de w bits. A instru¸cão SUBC efetua a subtra¸cão de dois operandos de w bits e em seguida subtrai o carry gerado pela opera¸cão anterior. As sintaxes dessas instru¸cões também estão detalhadas no Apêndice A.1.

Considerando os parâmetros adotados neste trabalho o tamanho máximo dos elementos de Fp é 254 bits. Logo a soma dos dois blocos da última posi¸cão não gerará carry. Ou seja,

a soma de dois elementos representados com W palavras resultar´a em um elemento tamb´em representado com W palavras.

O Algoritmo 5.1 apresenta um pseudoc´odigo que mostra como pode ser implementada a adi¸c˜_{ao em F}p de dois inteiros X, Y ambos de W palavras.

Na análise do custo computacional do Algoritmo 5.1 foram desconsiderados os custos de checagem de flags (ex: verificar o valor de flags de sinal, SF, ou de Zero, ZF), de parâmetros e de controle de itera¸cões de la¸cos. Será considerado que o custo de todas as instru¸cões tais como LOAD, STO, ADD, ADDC, SUB e SUBC, entre outras, é igual a a0. Sob estas condi¸cões,

Algoritmo 5.1 Adi¸c˜_{ao de inteiros de W palavras em F}p

1: _{function ADI ¸}_C˜_aO(X,Y) 2: _{Entrada: X, Y ∈ F}_p.

3: Sa´ıda: Z = Z (mod p).

4: //zera flag de carry

5: CLR(CF)

6: Para i = 0 at´e W-1

7: //lê conteúdo da posi¸cão de memória Xi para o registrador Ra

8: LOAD(Ra, Xi)

9: //lê conteúdo da posi¸cão de memória Yi para o registrador Rb

10: LOAD(Rb, Yi)

11: //soma o conte´udo do registrador Ra com o de Rb e com o carry

12: ADDC(Ra, Ra, Rb)

13: //armazena o conteúdo do registrador Ra na posi¸cão de memória Zi

14: STO(Ra, Zi)

15: //fim do la¸co i

16: //Verificar se p ≥ q

17: Para i = W-1 at´e 1

18: //lê conteúdo da posi¸cão de memória Zi para o registrador Ra

19: LOAD(Ra, Zi)

20: //lê conteúdo da posi¸cão de memória pi para o registrador Rb

21: LOAD(Rb, pi)

22: //subtrai o conte´udo do registrador Rb do conte´udo do registrador Ra

23: SUB(Ra, Ra, Rb)

24: //verifica a flag de sinal (negativo ou positivo)

25: Se SF = 1

26: //p´ara o la¸co i, pois Z < p

27: RETURN(Z)

28: //se SF = 0, o resultado ´e positivo (Z > p) ou (Z = p)

29: Sen˜ao

30: //se ZF = 0 o resultado ´e diferente de zero

31: Se ZF = 0

32: //zera flag de carry

33: CLR(CF)

34: Para k = 0 at´e W-1

35: //lê conteúdo da posi¸cão de memória Zk para o registrador Ra

36: LOAD(Ra, Zk)

37: //lê conteúdo da posi¸cão de memória pk para o registrador Rb

38: LOAD(Rb, pk)

39: //subtrai o conte´udo de Rb do conte´udo Ra e subtrai o carry desse resultado

Algoritmo 5.1 Adi¸c˜_{ao de inteiros de W palavras em F}p (continua¸c˜ao)

41: //armazena o conteúdo do registrador Ra na posi¸cão de memória Zi

42: STO(Ra, Zk)

43: //fim do la¸co k

44: //p´ara o la¸co i, pois Z < p

45: RETURN(Z)

46: //Sen˜ao continue o la¸co i

47: //fim do la¸co i

48: //lê conteúdo da posi¸cão de memória Z0 para o registrador Ra

49: LOAD(Ra, Z0)

50: //lê conteúdo da posi¸cão de memória p0 para o registrador Rb

51: LOAD(Rb, p0)

52: //subtrai o conte´udo de Rb do conte´udo de Ra

53: SUB(Ra, Ra, Rb)

54: //verifica a flag de sinal (negativo ou positivo)

55: Se SF = 1

56: RETURN(Z)

57: //se SF = 0, o resultado ´e positivo (Z > p) ou (Z = p)

58: Sen˜ao

59: //se ZF = 0 o resultado ´e diferente de zero

60: Se ZF = 0

61: //zera flag de carry

62: CLR(CF)

63: Para k = 0 at´e W-1

64: //lê conteúdo da posi¸cão de memória Zk para o registrador Ra

65: LOAD(Ra, Zk)

66: //lê conteúdo da posi¸cão de memória pk para o registrador Rb

67: LOAD(Rb, pk)

68: //subtrai o conte´udo de Rb do conte´udo Ra e subtrai o carry desse resultado

69: SUBC(Ra, Ra, Rb)

70: //armazena o conteúdo do registrador Ra na posi¸cão de memória Zi

71: STO(Ra, Zk)

72: //fim do la¸co k

73: RETURN(Z)

74: //se ZF = 1, o valor do conte´udo de Ra ´e zero, ou seja, Z = p

75: Sen˜ao

76: Para k = 0 at´e W-1

77: //armazena 0 = 0...0 (w bits zero) em todos as posi¸c˜oes de mem´oria de Zk

78: STO(0, Zk)

79: //fim do la¸co k 80: RETURN(Z)

pode-se fazer duas análises: a do melhor caso, onde o custo computacional é 4W a0 + 4a0, pois a verifica¸cão da palavra ZW −1 já permite concluir que Z < p, não sendo necessário verificar

outras palavras e nem efetuar redu¸cões módulo p. E a do pior caso, onde o custo computacional desse algoritmo é 11W a0 + 2a0, pois, para concluir que Z > p todas as palavras de Z precisam ser verificadas e ainda há a necessidade de efetuar uma redu¸cão módulo p (subtraindo p de Z). Demais informa¸cões sobre instru¸cões utilizadas no Algoritmo 5.1 que não foram citadas nesta se¸cão podem ser encontradas no Apêndice A.1.

No documento Avaliação do custo computacional de emparelhamentos bilineares sobre curvas elípticas Barreto-Naehrig (páginas 71-82)

4.3 Contagem de Opera¸c˜ oes

4.3.1 La¸co de Miller

4.3.2

Conclus˜oes

Cap´ıtulo

5

An´alise de Custo de Emparelhamentos

Bilineares no N´ıvel de Opera¸c˜oes de Processador

5.1

Algoritmo de Adi¸c˜ao em F

Algoritmo de Adi¸c˜_{ao em F}