wNAF(window Non-Adyacent Form) ( )2

Nombre: Gómez Ávila Karla Paulina
Materia: Análisis y Diseño de Algoritmos.
Profesor: Dr. Francisco Rodríguez Henríquez.
Tarea 2: Diseñar e implementar el
Departamento de Ingeniería Eléctrica
Sección de Computación
algoritmo WNAF para expansión de
coeficientes enteros.
Fecha de entrega: viernes 17 de marzo de
2006
wNAF(window Non-Adyacent Form)
Cuando calculamos nP con la multiplicación escalar de ECC, debemos primero
transformar el número entero n en forma binaria. Después se multiplica el número
binario con P, de esto resulta una curva elíptica típico de la multiplicación escalar. En
esta multiplicación, las probabilidades de cada bit con valor de ‘0’ o ‘1’ es de 1/2. Y
cuando la longitud de la entrada es n, entonces se necesita alrededor n tiempos de
ECDBL [1] y n/2 tiempos de ECADD [2] (para cada bit ‘1’ se necesita un cálculo de
ECDBL y uno de ECADD; y para cada bit ‘0’ se necesita solamente una vez ECDBL).
Pero si la multiplicación escalar es calculada con la forma NAF en vez de la forma
binaria, la velocidad de la multiplicación aumentará.
NAF es un especial wNAF con un tamaño de ventana de 2. La entrada binaria es
convertida de Derecha-a-Izquierda con las siguientes reglas: Cuando el bit actual es ‘0’,
será guardado, y cuando el bit actual sea ‘1’, los dos bits siguientes se deben tratar como
un bloque. Esto es, ‘01’ se mantiene como ‘01’ mientras que ‘11’ será substituido por
‘101’. En el segundo caso, el bloque genera un acarreo. Esto cambia el valor del
siguiente bit, pero esto no es problema para analizar las características asintóticas
(porque el bit siguiente puede ser ‘0’ o ‘1’, y cuando se obtiene un acarreo del bit
precedente, se tiene la misma distribución de ‘0’ y ‘1’). Esto ahorra una time de
ECADD con ‘0’ en lugar de ‘1’. Por esto cuando se calcula la multiplicación escalar de
las curvas elípticas con la forma NAF en vez de la forma binaria, se necesita solamente
alrededor n veces de ECDBL y n/3 veces de ECADD.
wNAF tiene un tamaño de ventana w y realiza la conversión de la forma binaria
de Derecha-a-Izquierda.
Definición wNAF: Una secuencia de dígitos con signo es llamada wNAF si
cumple las siguientes tres características:
1. El bit mas significativo no-cero es positivo.
2. Entre cada w dígitos consecutivos, al menos uno es un bit no-cero.
3. El valor absoluto de cada dígito no-cero es impar y menor que 2w-1.
Para dos puntos P1 y P2 en la curva E (K),
[1] P1 + P2 (P1 ≠ P2 ) es llamado ECADD y
[2] P1 + P2 = 2 P1 (P1 = P2 ) Es llamado ECDBL.
Existen diferentes algoritmos, que convierten la forma binaria en wNAF. El
algoritmo propuesto para este caso de estudio es propuesto por Solinas. En este, "a
mods b" se refiere a un modulo con signo, este es definido como a mod b, donde
b
b
− ≤ a ≤ , y esto significa que el “mods” genera a veces un acarreo. Los valores
2
2
posibles de los bits no-cero usados para wNAF son:
T = {±1, ±3, ±5,. . ., ± (2W−1 − 1)}
Algoritmo propuesto: Generación de wNAF
Entrada: tamaño de la ventana w, número entero d de n-bits
Salida: tamaño de la ventana w, {σ n , σ n−1 ,K , σ 0 }w que es el wNAF de d
i←0
while d ≥ 1 do
if d is even then
σ i ← 0;
else
σ i ← d mod s 2 w ;
d ← d −σi;
end if
d ← d / 2;
i ← i + 1;
end while
Return {σ n , σ n−1 ,K , σ 0 }w
Desarrollo del algoritmo propuesto en VHDL:
Este algoritmo fue desarrollado para un FPGA de la familia Spartan 2E.
Se implementaron 7 módulos principales como se muestran a continuación:
component mods
port(entrada : in std_logic_vector(1 downto 0);
enable : in std_logic;
clock : in std_logic;
salida : out std_logic_vector(3 downto 0));
end component;
component comparador
port(A: IN std_logic_VECTOR(162 downto 0);
A_GE_B: OUT std_logic);
end component;
component resta
port(A: IN std_logic_VECTOR(162 downto 0);
B: IN std_logic_VECTOR(3 downto 0);
S: OUT std_logic_VECTOR (164 downto 0));
end component;
component mux2
port(a0,a1 : in std_logic_vector(1 downto 0);
sel : in std_logic;
cout : out std_logic_vector(1 downto 0));
end component;
component mux163_reg
port(MA: IN std_logic_VECTOR(162 downto 0);
MB: IN std_logic_VECTOR(162 downto 0);
S: IN std_logic_VECTOR(0 downto 0);
Q: OUT std_logic_VECTOR(162 downto 0);
CLK: IN std_logic);
end component;
component mux163
port(ain,bin : in std_logic_vector(162 downto 0);
enable : in std_logic;
c : out std_logic_vector(162 downto 0));
end component;
component ciclo1
port(restain,escalarin : in std_logic_vector(162 downto 0);
win : in std_logic_vector(1 downto 0);
enable,sel : in std_logic;
salida : out std_logic_vector(162 downto 0);
wis : out std_logic_vector(1 downto 0));
end component;
Los módulos “mods” y “mux2” fueron desarrollados para esta arquitectura, y el
resto de los módulos se implementaron mediante un Core generator. Los códigos de
cada uno de los módulos fueron anexados.
El esquema sintetizado que presenta la herramienta como solución al problema
es la siguiente:
Fig. 1. Diagrama RTL de wNAF
La cual tiene como entrada el número escalar que será expandido y como salida
presenta la expansión de dicho escalar y el tamaño de la ventana que fue implementado.
A continuación se presentan los diagramas de algunos módulos creados:
Fig. 2 Esquema RTL expandido.
Fig. 3 Esquema RTL del módulo “mods”
Fig. 4 Esquema RTL del módulo que realiza los ciclos en el módulo “mods”
Fig. 5 Esquema RTL que realiza las comparaciones bit a bit para la resta.
Para poder implementar este algoritmo en la tarjeta propuesta se utilizó la
memoria interna de la tarjeta, aquí se depositaron las entradas y las salidas del circuito,
ya que al realizar la síntesis de la arquitectura presentaba un problema con el buffer de
entrada y salida ya que este era superado por las entradas y salidas del circuito, como se
presenta a continuación.
Reporte de síntesis:
Device utilization summary:
--------------------------Selected Device: 2s200epq208-7
Number of Slices:
Number of Slice Flip Flops:
Number of 4 input LUTs:
Number of bonded IOBs:
Number of GCLKs:
525 out of 2352 22%
336 out of 4704 7%
828 out of 4704 17%
348 out of 146 238% (*)
2 out of
4 50%
La memoria utilizada fue la siguiente:
-- RAMB4_S16: Virtex/E, Spartan-II/IIE 256 x 16 Single-Port RAM
-- Xilinx HDL Language Template version 8.1i
RAMB4_S16_inst : RAMB4_S16
generic map (
INIT_00 =>
X"1110000011111111001100101001001111100010000011001010000011000110",
INIT_01 =>
X"0110001010000101010100101100111001100110111110010111001011100010",
INIT_02 =>
X"0110000001010000111110011101100000000000000000000000000000000000",
INIT_03 =>
X"1001100001000000011010110010100101000011000100001011001010000101",
INIT_04 =>
X"1001011010110001010000101010101011011010011010110100110000110101",
INIT_05 =>
X"1001101011001100010101100000010100010000110100011011000000000000",
INIT_06 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_07 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_08 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_09 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0A =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0B =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0C =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0D =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0E =>
X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0F =>
X"0000000000000000000000000000000000000000000000000000000000000000")
port map (
DO => DO, -- 16-bit data output
ADDR => ADDR, -- 8-bit address input
CLK => CLK, -- Clock input
DI => DI, -- 16-bit data input
EN => EN, -- RAM enable input
RST => RST, -- Synchronous reset input
WE => WE -- RAM write enable input
);
-- End of RAMB4_S16_inst instantiation
Como se puede observar aquí fueron guardadas las entradas de los escalares
evaluados, y aquí mismo son guardas las salidas por el proceso.
Para comprobar los resultados se realizó el programa en Maple10.
wnaf := proc( )
local i, wn, a, d;
i := 162;
wn := Array( 0 ..162 );
a := 8;
while1 != d do
if mod (d, 2 ) = 0 then
wn [ i] := 0
else
wn [ i] := mods ( d, a );
d := d K wn [i]
end if;
d := 1 /2 * d;
i := i K 1
end do;
returnwn
end proc
Los resultados obtenidos se presentan fueron:
Fig. 6 Resultados wNAF con w =3;