En este artículo se presenta una implementación eficiente de sumadores carry-select en FPGA. Se ajustó el diseño del los sumadores a las restricciones impuestas por las FPGAs pertenecientes a la familia Virtex II de Xilinx. Se analizaron varios sumadores con operandos de hasta 512 bits y con bloques condicionales de diferentes tamaños. Se verificó que dependiendo del tamaño de estos bloques, los sumadores carry-select implementados en este trabajo poseen mejores tiempos de computo respecto de los sumadores ripple-carry.
Además se obtuvo una expresión matemática que puede utilizarse para determinar aproximadamente, en términos de velocidad, el tamaño óptimo de los bloques que conforman al sumador carry-select.VI Workshop de Procesamiento Distribuido y Paralelo (WPDP)Red de Universidades con Carreras en Informática (RedUNCI

Acosta, Nelson

Vázquez, Martín Osvaldo

Spanish

El Servicio de Difusión de la Creación Intelectual

  
 
 
Implementación de Sumadores rápidos Carry-Select en FPGA 
 
Martín Vázquez y Nelson Acosta 
INCA/INTIA – Facultad de Ciencias Exactas – UNICEN 
Paraje Arroyo Seco, Campus Universitario – Tandil, Argentina 
{ mvazquez | nacosta}@exa.unicen.edu.ar 
 
RESUMEN: En este artículo se presenta una implementación eficiente de sumadores carry-select en FPGA. Se 
ajustó el diseño del los sumadores a las restricciones impuestas por las FPGAs pertenecientes a la familia Virtex 
II de Xilinx. Se analizaron varios sumadores con operandos de hasta 512 bits y con bloques condicionales de 
diferentes tamaños.  Se verificó que dependiendo del tamaño de estos bloques,  los sumadores  carry-select 
implementados en este trabajo poseen mejores tiempos de computo respecto de los sumadores ripple-carry. 
Además se obtuvo una expresión matemática que puede utilizarse para determinar aproximadamente, en 
términos de velocidad, el tamaño óptimo de los bloques que conforman al sumador carry-select. 
Palabras Claves:  Sumador Carry-Select; RLOC;  FPGA 
 
1. Introducción 
La alta densidad de las FPGA de hoy ha posibilitado el diseño de sistemas en un solo chip. El uso de 
núcleos de propiedad intelectual (core-IP) [1], en este tipo de sistemas tiene múltiples ventajas: se evita 
la utilización de componentes extras, se reduce las conexiones fuera del chip y, por último, la solución 
puede optimizarse respecto de la aplicación, considerando aspectos como frecuencia de operación, 
precisión, etc. La generación de modelos VHDL sintetizables que permitan implementar las principales 
funciones aritméticas con FPGA, es una parte esencial en un ambiente de diseño utilizando cores-IP.  
Los sumadores binarios son fundamentales en una gran variedad de sistemas digitales y se utilizan en 
todas las operaciones aritméticas [2]. Abarcan un amplio rango de aplicaciones, desde el cómputo de 
una dirección física, cada vez que la computadora realiza una operación de fetch;  hasta en algoritmos 
de encriptación, DSP, etc [3].  
Las FPGA son particularmente atractivas para implementar sumadores que utilizan ripple-carry debido 
al uso de conexiones dedicadas que posibilitan la propagación rápida del carry [4]. Aquellos sumadores 
cuya arquitectura incluye ripple-carry pueden implementarse eficientemente en FPGAs, tal es el caso 
de sumadores como carry-skip [5], o como se muestra en este trabajo el sumador carry-select, entre 
otros. 
Este trabajo presenta una implementación a medida (full custom) sobre FPGA de sumadores carry-
select. Para ello, se realizaron descripciones en VHDL utilizando técnicas de emplazamiento relativo 
(RLOC: relative location) [6], sujetas a las restricciones impuestas por las FPGAs de la familia Virtex 
II de Xilinx.  
Se analizaron varios sumadores, con operandos desde 64 bits hasta 512 bits y con bloques 
condicionales de diferentes tamaños. También se obtuvo una expresión matemática que posibilita 
determinar aproximadamente, cuál es el tamaño óptimo de los bloques que conforman el carry-select 
para que sea más rápido.  Los resultados adquiridos en el presente trabajo son muy alentadores en el 
contexto de operaciones rápidas con operandos grandes.  
 
2. Sumador carry-select 
El sumador carry-select de n bits se descompone en grupos en n/r bloques sumadores ripple-carry de r 
bits. Cada bloque genera un resultado y un carry. El sumador carry-select (Fig. 1) se basa en la 
realización de dos sumas de grupos de bits en paralelo: uno con entrada de carry en 0 y otro con 
 entrada de carry en 1. Una vez calculado el valor real del carry se selecciona el resultado de la suma 
correspondiente. 
 
 
cinFA-r
a(r-1:0) b(r-1:0)a(2.r-1:r) b(2.r-1:r)
s(r-1:0)
s(2.r-1:r)
FA-rFA-r 0 1
Mux-r
0
0 1
1 q(r)q(2.r)...
a(i.r+r-1:i.r) b(i.r+r-1:i.r)
s(i.r+r-1:i.r)
FA-rFA-r 0 1
Mux-r
0
0 1
1 q(i.r)q((i+1).r)
Bloque 1 Bloque 0Bloque i
 
Figura 1. Arquitectura del sumador  carry-select de n bits 
 
El costo y tiempo de computación de un sumador carry-select de n bits se pueden modelar de la 
siguiente manera: 
 
CCarry-Select(n) = (2.(n/s-1) +1).CFA-r + (n/s -1).(CMux-r+ CMux ) 
TCarry-Select(n)  = TFA-r + (n/s -1).TMux  
 
en donde Mux-r está asociado a un multiplexor 2 a 1 de r bits, Mux a un multiplexor 2 a 1 de 1 bit y 
FA-r a un sumador completo de r bits (full adder). 
  
3. Sumador ripple-carry en FPGA 
En general, las FPGAs contienen recursos dedicados para generar sumadores rápidos. Los dispositivos 
programables pertenecientes a la familia Virtex II de Xilinx,  incluyen puertas lógicas, multiplexores y 
tablas look-up de propósito general, que posibilitan construir de manera eficiente sumadores ripple-
carry. En la Fig. 3 se aprecia como se utilizan los recursos en un CLB de Virtex II para implementar un 
sumador completo ripple-carry de 4 bits (CLB Sum-4). 
La propagación de carry se realiza mediante el uso de conexiones dedicadas y el uso de multiplexores 
rápidos. Las tablas de look-up calculan la función de propagación de carry 
 
p(i) = x(i) xor y(i) 
 
de esta manera  
 
q(i+1) = g(i) + p(i).q(i) 
 
se deduce  
 
g(i) + p(i).q(i) = a(i).b(i) + (a(i) xor b(i)).q(i) = 
not(a(i) xor b(i)).a(i) + (a(i) xor b(i)).q(i)  = 
not(p(i)).a(i) + p(i).q(i)  
 
  
 
 
LUT 0 1
b(4.i+3)
a(4.i+3)
p(4.i+3)
LUT 0 1
b(4.i+2)
a(4.i+2)
p(4.i+2)
q(4.i+2)
s(4.i+3)
s(4.i+2)
LUT 0 1
b(4.i+1)
a(4.i+1)
p(4.i+1)
LUT 0 1
b(4.i)
a(4.i)
p(4.i+1)
q(4.i)
s(4.i+1)
s(4.i)
q(4.i+1)
q(4.i-1)
q(4.i+3)Slice (x,y+1)
Slice (x,y)
 
Figura 2.  Implementación de un sumador ripple-carry de 4 bits en Virtex II 
 
El tiempo de cálculo TRipple(n) de un sumador ripple-carry de n bits es 
 
TRipple(n) = tLUT + n.tmux-cy 
 
donde tLUT  es el tiempo de cómputo de una tabla look-up y tmux-cy es el retraso del multiplexor dedicado 
junto con la conexión al slice adyacente. 
El tmux-cy es mucho menor que el retraso que se produce cuando se genera un multiplexor con una 
tabla de look-up y se establece una conexión de propósito general. 
El costo CRipple(n) asociado a la cantidad de slices que ocupa la implementación el sumador ripple-
carry de n bits es  
 
CRipple(n) = n/2 slices 
 
4. Implementación del sumador carry-select en FPGA 
Se implementaron varios sumadores en una FPGA de la familia Virtex II de Xilinx (xc2v4000-6ff517), 
con una matriz de 144x160 slices. La síntesis se realizó con XST (Xilinx Synthesis Technology) [7] y 
la implementación física con el Xilinx ISE (Integrated System Environment) versión 6.3i [8]. Para 
aprovechar al máximo los recursos de la FPGA, el diseño se efectuó instanciando componentes de bajo 
nivel mediante la utilización de técnicas de RLOC. 
La implementación de cada bloque i (Blqi) de r bits (con i>0) que conforma al sumador carry-select de 
n bits, se compone de r/8 subbloques (SubBlq) de 8 bits. En la fig. 3 se observa la implementación en 
Vitrtex II del subbloque j de 8 bits perteneciente a un bloque i de r bits (SubBlqi,j). La implementación 
 de los slices del CLB SumSel-4 son similares a los slices del CLB Sum-4 descriptos en la Fig. 2, la 
diferencia es que el CLB SumSel-4 implementa  los dos sumadores alternativos, uno para carry de 
entrada en 0 y otro para carry de entrada en 1. El CLB Mux-8 implementa un multiplexor 2 a 1 de 8 
bits. 
 
s(m+1)
Slice
Slice r(m+3:m+2)
q0(m)
r(m+1:m)
Slice
Slice rr(m+3:m+2)
rr(m+1:m)a(m+1:m)
b(m+1:m)
b(m+3:m+2)
a(m+3:m+2)
Slice
Slice r(m+7:m+6)
r(m+5:m+4)
Slice
Slice rr(m+7:m+6)
rr(m+5:m+4)a(m+5:m+4)
b(m+5:m+4)
b(m+7:m+6)
a(m+7:m+6)
CLB  SumSel-4
CLB  SumSel-4
Slice
Slice
Slice
Slice
CLB  Mux-8
s(m+7:m+6)
s(m+5:m+4)
s(m+3:m+2)
s(m+1:m)
LUT
r(m+1)
rr(m+1)
LUT s(m)
r(m)
rr(m)
q(i.r)
q1(m)
q0(m+8) q1(m+8)
q(i.r)
q(i.r)
 
Figura 3.  Implementación en Vitrtex II de un SubBlqi,j de 8 bits. Donde m = i.r + 8.j 
 
El costo CSubBlq asociado a cada subbloque de 8 bits es de 12 slices  
La Fig. 4 muestra como se utilizaron los CLBs en Virtex II para implementar un bloque i de r bits. El 
CLB Mux-1 sólo utiliza una LUT de un slice, la cual describe un multiplexor 2 a 1 de 1 bit. 
El costo CBlq i de un bloque i (i>0) de r bits está determinado por: 
 
CBlq i  = (r/8).CSubBlq  + CMux-1 = (r/8).12 + 1 = (3/2).r + 1 slices 
 
El bloque 0 implementa un sumador completo de r bits. El costo CBlq 0 del bloque 0 de r bits es: 
 
CBlq 0  =  r/2 slices 
 
En la fig. 5 se observa el enplazado en la FPGA de los diferentes bloques que conforman el sumador 
carry-select de n bits. 
 
  
 
 
SumSel-4
SumSel-4 Mux-8
...
a(i.r+r-1:i.r+r-4)
b(i.r+r-1:i.r+r-4)
a(i.r+r-5:i.r+r-8)
b(i.r+r-5:i.r+r-8)
s(i.r+r-1:i.r+r-8)
q0((i+1).r) q1((i+1).r)
Mux-1
...
q((i+1).r)
q(i.r)
SumSel-4
SumSel-4 Mux-8
a(i.r+7:i.r+4)
b(i.r+7:i.r+4)
a(i.r+3:i.r)
b(i.r+3:i.r)
s(i.r+7:i.r)
q0(i.r+8) q1(i.r+8)
0 1
q0(i.r+r-8) q1(i.r+r-8)
...
Bloque i (i>0)
Sum-4
Sum-4
...
a(r-1:r-4)
b(r-1:r-4)
a(r-5:r-8)
b(r-5:r-8)
s(3:0)
q(r)
Sum-4
Suml-4
a(7:4)
b(7:4)
a(3:0)
b(3:0)
q(8)
cin
q(r-8)
s(7:4)
s(r-5:r-8)
s(r-1:r-4)
Bloque 0
 
Figura 4.  Implementación en Vitrtex II de un bloque i de r bits. 
 
 
Bloque
0
cin
a(r-1:0)
b(r-1:0)
Bloque
1
a(2.r-1:r)
b(2.r-1:r)
q(r)
s(2.r-1:r)s(r-1:0)
q(2.r)
a(i.r+r-1:i.r)
b(i.r+r-1:i.r)
q(i.r)
s(i.r+r-1:i.r)
q((i+r).r)
Bloque
i
...
...
a(n-1:n-r)
b(n-1:n-r)
q(n-r)
s(n-1:n-r)
cout
Bloque
n/r-1
...
...
 
Figura 5.  Emplazado del sumador carry-select de n bits. 
 
 
El costo CCarrry-Select de implementar el sumador carry-select de n bits con bloques de r bits en una 
Virtex II es 
 
CCarrry-Select(n) = CBlq 0 + (n/r-1).CBlq i  = r/2 +  (n/r-1).((3/2).r + 1)  slices 
 
CCarrry-Select(n) = (3/2 + 1/r ).n - r – 1  slices    (1) 
 
Expresando el costo CCarrry-Select(n)  en función del tamaño de bloque se obtiene 
g(r) = CCarrry-Select(n) = (3/2 + 1/r ).n - r - 1        
  
se observa que para sumadores del mismo tamaño,  el costo disminuye a medida que crece r. 
Para el análisis de tiempos que se realiza a continuación se consideran los siguientes aspectos: a) tcnx1 
está asociado al tiempo de conexión promedio entre un slice del CLB SumSel-4 a un slice del CLB 
Mux-8, o al tiempo de conexión de las señales a(i) y b(i), o al tiempo entre un slice del CLB SumSel-4 
y un slice correspondiente al CLB Mux-1 (Fig. 3 y Fig. 4 ); b) tcnx2 está asociado al tiempo de conexión 
promedio entre la salida asociada a q(i.r) y un slice de Mux-1; y c) tcnx3 es el tiempo de conexión 
promedio entre la salida asociada a q(i.r) y un slice correspondiente a Mux-8. Se puede verificar 
fácilmente que tcnx3 >tcnx2 > tcnx1. Se asume además, que tk es el tiempo de computo que insume calcular 
la salida k. 
Para el bloque 0: 
tq(r)  = TRipple + tcnx1 
= tLUT + r.tmux-cy + tcnx1 
ts(r-1:0)  = tLUT + r.tmux-cy + tcnx1 
 
Para el bloque 1: 
tq(2.r)  = max{ tq(r)+ tcnx2, TRipple + 2.tcnx1}+ tLUT 
= 2.tLUT + r.tmux-cy + tcnx2 + tcnx1 
ts(2.r-1:r)  = max{ tq(r)+ tcnx3, TRipple + 2.tcnx1}+ tLUT 
= 2.tLUT + r.tmux-cy + tcnx3 + tcnx1 
 
Para el bloque 2 
tq(3.r)  = max{ tq(2.r)+ tcnx2, TRipple + 2.tcnx1}+ tLUT 
= 3.tLUT + r.tmux-cy + 2.tcnx2 + tcnx1 
ts(2.r+r-1:2.r) = max{ tq(2.r)+ tcnx3, TRipple + 2.tcnx1}+ tLUT 
= 3.tLUT + r.tmux-cy + tcnx2 + tcnx3 + tcnx1 
 
Para el bloque 3 
tq(4.r)  = tq(3.r)+ tcnx2 + tLUT 
= 4.tLUT + r.tmux-cy + 3.tcnx2 + tcnx1 
ts(3.r+r-1:3.r) = tq(3.r)+ tcnx3 + tLUT 
= 4.tLUT + r.tmux-cy + 2.tcnx2 + tcnx3 + tcnx1 
 
Para el bloque i 
tq((i+1).r)  = (i+1).tLUT + r.tmux-cy + i.tcnx2 + tcnx1 
ts(i.r+r-1:i.r) = (i+1).tLUT + r.tmux-cy + (i-1).tcnx2 + tcnx3 + tcnx1 
 
Considerando m =n/r, los tiempos asociados a las salidas de último bloque (m-1) son: 
tq(m.r)  = m.tLUT + r.tmux-cy + (m-1).tcnx2 + tcnx1 
tq(n)  = (n/r).tLUT + r.tmux-cy + (n/r –1).tcnx2 + tcnx1 
 
ts(m.r -1:m.r-r) = m.tLUT + r.tmux-cy + (m-2).tcnx2 + tcnx3 + tcnx1 
ts(n-1:n-r) = (n/r).tLUT + r.tmux-cy + (n/r –2).tcnx2 + tcnx3 + tcnx1 
 
Por consiguiente el tiempo de cómputo máximo TCarry-Select(n) asociado a la implementación del 
sumador carry-select de n bits con bloques de r bits en una Virtex II es 
  
 
 
TCarrry-Select(n) = (n/r).tLUT + r.tmux-cy + (n/r -2).tcnx2 + tcnx3 + tcnx1     (2) 
 
Asumiendo C = tcnx3 + tcnx1 – 2.tcnx2, la ecuación anterior (2) se puede expresar de la siguiente manera  
TCarrry-Select(n) = (n/r).(tLUT + tcnx2) + r.tmux-cy + C 
 
Expresando el tiempo de cómputo TCarrry-Select(n) en función del tamaño de bloque 
 
f(r) = TCarrry-Select(n) = (n/r).(tLUT + tcnx2) + r.tmux-cy + C 
 
para encontrar el valor aproximado de r que minimice la expresión f(r) 
 
f ’(r) = -(n/r2).(tLUT + tcnx2) + tmux-cy = 0 
entonces 
r = [n.(tLUT + tcnx2)/tmux-cy]½ 
 
Experimentalmente se verificó que  
(tLUT + tcnx2)/ tmux-cy  31 
 
de este modo 
r   5,5 .(n)½ (3) 
 
5. Resultados Experimentales 
En la tabla 1 se listan los peores retrasos obtenidos por la implementación de los sumadores carry-
select, para diferentes tamaños de operandos y bloques (n y r respectivamente). Para el caso que el 
tamaño de los operandos es igual al tamaño de los bloques (n=r), se obtiene un sumador ripple-carry 
convencional. Nótese que existen celdas en las cuales no existe información, esto es porque n no es 
divisible por r, o bien, en el caso de (*), porque la implementación propuesta en este trabajo para el 
sumador con estos parámetros (n y r) no se puede emplazar, ya que el número de columnas de CLBs 
para esa cantidad de bloques (n/r) excede el límite de la FPGA utilizada (xc2v4000-6ff517). 
 
    r 
n 
8 16 32 64 80 96 112 128 160 192 224 256 320 384 448 512 
64 10,9 7,2 5,7 6 - - - - - - - - - - - - 
128 19 11,1 8,5 7,5 - - - 8,7 - - - - - - - - 
192 28 16,1 10,4 9,5 - 9,6 - - - 11,3 - - - - - - 
256 (*) 19 12,3 9,9 - - - 11,5 - - - 14 - - - - 
320 (*) 23,8 14,8 11,2 11,2  - - 13,7 - - - 19,2 - - - 
384 (*) (*) 16,8 12,9 - 12,5 - 12,6 - 15,3 - - - 22,8 - - 
448 (*) (*) 19 14 - - 12,8 - - - 15,8 - - - 26,3 - 
512 (*) (*) 20,9 15 - - - 14,9 - - - 17,9 - - - 29,7 
Tabla 1. Resultados experimentales: Perores tiempos de cálculo en ns.  
 
La tabla 2 muestra la evaluación de la expresión (3) para los diferentes tipos de operandos y la 
aproximación al tamaño real del bloque (r). Se tomó como aproximación, el r divisor de n más cercano 
al resultado producido por (3). Se observa que la expresión matemática desarrollada para determinar el 
tamaño de bloque óptimo de manera que el sumador carry-select de n bits sea más rápido, produce un 
valor que aproximado a raprox, coincide con el tamaño de r resaltado para cada n en la tabla 1. 
 n 5,5.(n)½ raprox 
64 44 32 
128 62 64 
192 76 64 
256 88 64 
320 98 80 
384 108 96 
448 116 112 
512 124 128 
 Tabla 2. Validación de la expresión que determina r optimo para sumador más rápido 
 
En tabla 3 se aprecia el área ocupada por la implementación de los diferentes sumadores. El número de 
slices ocupado por cada sumador está determinado por (1), se observa que el sumador ripple-carry 
(n=r) presenta la menor ocupación de área. 
 
    r 
n 
8 16 32 64 80 96 112 128 160 192 224 256 320 384 448 512 
64 95 83 65 32 - - - - - - - - - - - - 
128 199 183 163 129 - - - 64 - - - - - - - - 
192 303 283 261 226 - 193 - - - 96 - - - - - - 
256 (*) 383 359 323 - - - 257 - - - 128 - - - - 
320 (*) 483 457 420 403 - - - 321 - - - 160 - - - 
384 (*) (*) 555 517 - 483 - 450 - 385 - - - 192 - - 
448 (*) (*) 653 614 - - 563 - - - 449 - - - 224  
512 (*) (*) 751 711 - - - 643 - - - 513 - - - 256 
Tabla 3. Resultados experimentales: Ocupación de slices. 
 
Para determinar el tamaño de bloque que maximice la  relación tiempo de cómputo y ocupación de 
slices (tiempo-área),se consideró la siguiente expresión  
(n,r) = 1/ [ T(n,r) * C(n,r) ]   (4) 
 
donde T(n,r) y C(n,r) son el tiempo de cómputo y el costo en área respectivamente, asociados al 
sumador de n bits con tamaño de bloque de r bits. De este modo, para un determinado n, el r óptimo es 
ropt(n) = max ((n,r))  para todo r divisor de n (5) 
 
La tabla 4 muestra la relación tiempo-área () para cada sumador implementado. Para realizar el 
cálculo de  (4), se expresó el tiempo de cómputo T(n,r) en microsegundos. Se observa que para todos 
los tamaños de operandos estudiados, el sumador ripple-carry (ropt=n) posee la mejor relación tiempo-
área. 
 
 
 
 
  
 
 
    r 
n 
8 16 32 64 80 96 112 128 160 192 224 256 320 384 448 512 
64 0,97 1,67 2,7 5,21 - - - - - - - - - - - - 
128 0,26 0,49 0,72 1,03 - - - 1,8 - - - - - - - - 
192 0,12 0,22 0,37 0,47 - 0,54 - - - 0,92 - - - - - - 
256 - 0,14 0,23 0,31 - - - 0,34 - - - 0,56 - - - - 
320 - 0,89 0,15 0,21 0,22 - - - 0,23 - - - 0,33 - - - 
384 - - 0,11 0,15 - 0,17 - 1,77  0,17 - - - 0,23 - - 
448 - - 0,08 0,12 - - 0,14 - - - 0,14 - - - 0,17  
512 - - 0,06 0,09 - - - 0,1 - - - 0,11 - - - 0,13 
Tabla 4. Relación tiempo-área (). 
 
6. Conclusiones 
En el presente trabajo se realizó la implementación eficiente en FPGA de diferentes sumadores carry-
select, con operandos de hasta 512 bits y bloques de diferentes tamaños. Para ello se utilizó la técnica 
de emplazado relativo.  
Se obtuvo que los sumadores carry-select,  para ciertos tamaños de bloque, son más rápidos que los 
sumadores ripple-carry. En cuanto al costo, se verificó que éste disminuye a medida que aumenta el 
tamaño de bloque, obteniéndose que el  sumador ripple-carry posee el menor costo.  
Además se determinó que el sumador ripple-carry es el que posee la mejor relación tiempo-área. 
Se desarrolló y validó experimentalmente una expresión matemática que posibilita determinar a priori, 
el tamaño de bloque que permite que un sumador carry-select de n bits sea más eficiente en términos 
de velocidad o tiempo de cómputo.  
 
7. Referencias 
[1] G. Spivey, S. Bhattacharyya, K. Nakajima, “Logic Foundry: Rapid Prototyping for FPGA-Based 
DSP Systems”. EURASIP Journal on Applied Signal Processing 2003, pp 565-579. Hindawi 
Publishing Corporation, 2003 
[2] P. Corsonello, V. Kantabutra, S. Perri, "Fast, Low-Cost Adders Using Carry Strength Signals", 
SSGRR 2000, l'Aquila, Italia, Julio 31-Aug 6. 
[3] E. Jamro, K. Wiatr, “Convolution operation implemented in FPGA structures for real-time image 
processing” Ernest Jamro, Kazimierz Wiatr, ISPA 2001 : proceedings of the 2nd international 
symposium on Image and Signal Processing and Analysis : in conjunction with 23nd international 
conference on Information technology interfaces, Junio 2001 
[3] P. Corsonello, V. Kantabutra, S. Perri, "Fast, Low-Cost Adders Using Carry Strength Signals", 
SSGRR 2000, l'Aquila, Italia, Julio 31-Aug 6. 
[4] Xilinx, inc. “Virtex-II Platform FPGAs: Complete Data Sheet ”, Marzo 2005, disponible en 
http://support.xilinx.com 
[5] G.Bioul, J-P.Deschamps, G. Sutter, “Efficient FPGA Implementation of Carry-Skip Adders”, III 
JCRA, España, Sept 2003. ISBN 84-600-9928-8. Pp 81-90. 
[6] Xilinx, inc. “Constraints Guide – ISE6.3i”, capítulo 2 Relative Location (RLOC), Agosto 2004, 
disponible en http://support.xilinx.com. 
[7] Xilinx, inc. “Xilinx Synthesis Technology  (XST) User Guide”, 2004, available at  
http://support.xilinx.com 
[8]  Xilinx, inc. “ISE6.3i Documentation”, 2004, disponible en http://support.xilinx.com 
 


Implementación de sumadores rápidos Carry-Select en FPGA

http://sedici.unlp.edu.ar/bitstream/handle/10915/23173/Documento_completo.pdf?sequence=1

Implementación de sumadores rápidos Carry-Select en FPGA

Abstract

Similar works

Full text

Available Versions

El Servicio de Difusión de la Creación Intelectual