Post on 13-May-2018
Jucemar Luis Monteiro
Hierarchical Add-One Carry-Select Adder: UmSomador Select-Adder com Cadeia de Carry
Logarítmica
Florianópolis, Santa Catarina
2011.1
Jucemar Luis Monteiro
Hierarchical Add-One Carry-Select Adder: UmSomador Select-Adder com Cadeia de Carry
Logarítmica
Trabalho de Conclusão de Curso apresentadocomo parte dos requisitos para obtenção do graude Bacharel em Ciências da Computação.
Orientador:
Prof. Dr. José Luís Almada Güntzel
UNIVERSIDADE FEDERAL DE SANTA CATARINA
CENTRO TECNOLÓGICO
DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA
Florianópolis, Santa Catarina
2011.1
Trabalho de conclusão de curso sob o título “Hierarchical Add-One Carry-Select Adder:
Um Somador Select-Adder com Cadeia de Carry Logarítmica”, defendido por Jucemar Luis
Monteiro e aprovado em 01 de junho de 2011, em Florianópolis, Santa Catarina, pela banca
examinadora constituída pelos professores:
Prof. Dr. José Luís Almada GüntzelUniversidade Federal de Santa Catarina
Orientador
Prof. Dr. Eduardo Luiz Ortiz BatistaUniversidade Federal de Santa Catarina
Membro da Banca
Prof. Dr. Djones Vinícius LettninUniversidade Federal de Santa Catarina
Membro da Banca
Agradecimentos
Em primeiro lugar agradeço aos meus pais por todo apoio e incentivo que me proporciona-
ram durante a graduação.
Ao Professor Güntzel pela orientação no desenvolvimento deste trabalho. Também agra-
deço aos membros da banca pelas sugestões e correções.
A todos os colegas do LAPS. Em especial ao Vinicíus Livramento e ao Pedro Campos pela
contribuição no desenvolvimento deste trabalho e aos Professores Olinto José Varela Furtado e
Luiz Cláudio Villar dos Santos pela avaliação do trabalho na disciplina Trabalho de Conclusão
de Curso I.
A todos os meus amigos pelo incentivo e amizade desde os tempos de CEFET/SC. Obrigado
Rodolfo Cruz, Rodrigo Rothbath, Bruno Volkov, Douglas Machado e Luciano Martin. Em
especial agradeço ao Professor Willy Sommer pelo incentivo e ajuda quando eu comecei a
graduação.
Agradeço às bolsas de iniciação científica ITI-A do CNPq via projetos SiSRAS e BRAZIL-
IP.
Agradeço ao AC/DC, Iron Maiden, Black Sabbath e Scorpions pela trilha sonora.
“Construímos muros demais e pontes de menos.”
Isaac Newton
Sumário
Lista de Figuras
Lista de Tabelas
Lista de Acrônimos p. 13
Resumo p. 15
Abstract p. 16
1 Introdução p. 17
1.1 A Adição Binária em Hardware . . . . . . . . . . . . . . . . . . . . . . . . p. 17
1.2 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 18
1.2.1 Objetivos Gerais . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 18
1.2.2 Objetivos Específicos . . . . . . . . . . . . . . . . . . . . . . . . . . p. 18
1.3 Escopo deste Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 18
1.4 Projeto de Circuitos Integrados Customizados e Metodologia de Projeto Ba-
seado em Células (Cell-Based Design) . . . . . . . . . . . . . . . . . . . . . p. 19
1.4.1 Projeto de Circuitos Integrados Customizados . . . . . . . . . . . . . p. 19
1.4.2 Metodologia Cell-Based Design . . . . . . . . . . . . . . . . . . . . p. 19
1.5 Organização deste Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 21
2 Arquiteturas Básicas de Somadores p. 22
2.1 Carry-Ripple Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 22
2.1.1 Half-Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 22
2.1.2 Full-Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 23
2.1.3 Arquitetura Carry-Ripple Adder . . . . . . . . . . . . . . . . . . . . p. 24
2.2 Carry-Lookahead Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 25
2.3 Carry-Select Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 29
3 Add-One Adders p. 31
3.1 Add-One Carry-Select Adder . . . . . . . . . . . . . . . . . . . . . . . . . . p. 31
3.2 Hierarchical Add-One Carry-Select Adder . . . . . . . . . . . . . . . . . . . p. 36
4 Síntese Lógica dos Somadores p. 39
4.1 Configuração Experimental . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 39
4.2 Controle do Processo de Otimização no Design Compiler . . . . . . . . . . . p. 41
4.3 Somadores Descritos em Formato de Árvore Binária . . . . . . . . . . . . . p. 42
4.4 Somadores Descritos com os Blocos Básicos em Formato de Cascata . . . . . p. 45
4.5 Verificação Funcional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 46
4.6 Provável Esquemático do Full-Adder da Biblioteca . . . . . . . . . . . . . . p. 47
5 Resultados Experimentais p. 48
5.1 Blocos Básicos Carry-Ripple Adder e Carry-Lookahead Adder . . . . . . . . p. 48
5.1.1 Atraso Crítico para os Blocos Básicos . . . . . . . . . . . . . . . . . p. 48
5.1.2 Consumo de Potência para os Blocos Básicos . . . . . . . . . . . . . p. 49
5.1.3 Área para os Blocos Básicos . . . . . . . . . . . . . . . . . . . . . . p. 50
5.1.4 Power-Delay Product para os Blocos Básicos . . . . . . . . . . . . . p. 51
5.1.5 Consumo de Potência por Unidade de Área para os Blocos Básicos . p. 52
5.2 Atraso Crítico para os Somadores . . . . . . . . . . . . . . . . . . . . . . . p. 53
5.3 Consumo de Potência para os Somadores . . . . . . . . . . . . . . . . . . . p. 57
5.4 Área para os Somadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 61
5.5 Power-Delay Product para os Somadores . . . . . . . . . . . . . . . . . . . p. 64
5.6 Consumo de Potência por Unidade de Área para os Somadores . . . . . . . . p. 67
6 Conclusões e Trabalhos Futuros p. 69
6.1 Conclusões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 69
6.2 Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 69
Referências Bibliográficas p. 71
Anexo A -- Células da Biblioteca Utilizadas na Síntese Lógica p. 73
Anexo B -- Artigo p. 76
Anexo C -- Código Fonte dos Somadores (Verilog) p. 84
C.1 Código Fonte do Add-One Carry-Select Adder . . . . . . . . . . . . . . . . . p. 84
C.1.1 Código Fonte do Add-One Carry-Select Adder 8 bits . . . . . . . . . p. 84
C.1.2 Código Fonte do Add-One Carry-Select Adder 16 bits . . . . . . . . p. 89
C.1.3 Código Fonte do Add-One Carry-Select Adder 32 bits . . . . . . . . p. 90
C.1.4 Código Fonte do Add-One Carry-Select Adder 64 bits . . . . . . . . p. 92
C.1.5 Código Fonte do Add-One Carry-Select Adder 128 bits . . . . . . . . p. 95
C.1.6 Código Fonte do Add-One Carry-Select Adder 256 bits . . . . . . . . p. 100
C.2 Código Fonte do Hierarchical Add-One Carry-Select Adder . . . . . . . . . p. 109
C.2.1 Código Fonte do Hierarchical Add-One Carry-Select Adder 8 bits . . p. 109
C.2.2 Código Fonte do Hierarchical Add-One Carry-Select Adder 16 bits . p. 116
C.2.3 Código Fonte do Hierarchical Add-One Carry-Select Adder 32 bits . p. 117
C.2.4 Código Fonte do Hierarchical Add-One Carry-Select Adder 64 bits . p. 119
C.2.5 Código Fonte do Hierarchical Add-One Carry-Select Adder 128 bits . p. 120
C.2.6 Código Fonte do Hierarchical Add-One Carry-Select Adder 256 bits . p. 122
C.3 Código Fonte do Carry-Ripple Adder . . . . . . . . . . . . . . . . . . . . . p. 123
C.3.1 Código Fonte do Carry-Ripple Adder 8 bits . . . . . . . . . . . . . . p. 123
C.3.2 Código Fonte do Carry-Ripple Adder 16 bits . . . . . . . . . . . . . p. 126
C.3.3 Código Fonte do Carry-Ripple Adder 32 bits . . . . . . . . . . . . . p. 127
C.3.4 Código Fonte do Carry-Ripple Adder 64 bits . . . . . . . . . . . . . p. 128
C.3.5 Código Fonte do Carry-Ripple Adder 128 bits . . . . . . . . . . . . . p. 129
C.3.6 Código Fonte do Carry-Ripple Adder 256 bits . . . . . . . . . . . . . p. 130
C.4 Código Fonte do Carry-Lookahead Adder . . . . . . . . . . . . . . . . . . . p. 131
C.4.1 Código Fonte do Carry-Lookahead Adder 8 bits . . . . . . . . . . . p. 131
C.4.2 Código Fonte do Carry-Lookahead Adder 16 bits . . . . . . . . . . . p. 141
C.4.3 Código Fonte do Carry-Lookahead Adder 32 bits . . . . . . . . . . . p. 142
C.4.4 Código Fonte do Carry-Lookahead Adder 64 bits . . . . . . . . . . . p. 143
C.4.5 Código Fonte do Carry-Lookahead Adder 128 bits . . . . . . . . . . p. 145
C.4.6 Código Fonte do Carry-Lookahead Adder 256 bits . . . . . . . . . . p. 146
C.5 Código Fonte do Carry-Select Adder . . . . . . . . . . . . . . . . . . . . . . p. 148
C.5.1 Código Fonte do Carry-Select Adder 8 bits . . . . . . . . . . . . . . p. 148
C.5.2 Código Fonte do Carry-Select Adder 16 bits . . . . . . . . . . . . . . p. 153
C.5.3 Código Fonte do Carry-Select Adder 32 bits . . . . . . . . . . . . . . p. 154
C.5.4 Código Fonte do Carry-Select Adder 64 bits . . . . . . . . . . . . . . p. 156
C.5.5 Código Fonte do Carry-Select Adder 128 bits . . . . . . . . . . . . . p. 159
C.5.6 Código Fonte do Carry-Select Adder 256 bits . . . . . . . . . . . . . p. 164
Lista de Figuras
2.1 Carry-Ripple Adder de n bits. . . . . . . . . . . . . . . . . . . . . . . . . . . p. 24
2.2 Carry-Lookahead Adder de 4 bits. . . . . . . . . . . . . . . . . . . . . . . . p. 27
2.3 Carry-Lookahead Adder hierárquico de 16 bits. . . . . . . . . . . . . . . . . p. 28
2.4 Carry-Select Adder de 16 bits. . . . . . . . . . . . . . . . . . . . . . . . . . p. 30
3.1 Add-One Carry-Select Adder e Add-One Block para 4 bits. . . . . . . . . . . p. 32
3.2 Bloco Add-One Carry-Select Adder. . . . . . . . . . . . . . . . . . . . . . . p. 35
3.3 Add-One Carry-Select Adder de 16 bits. . . . . . . . . . . . . . . . . . . . . p. 36
3.4 Hierarchical Add-One Carry-Select Adder de 16 bits. . . . . . . . . . . . . . p. 36
3.5 Add-One Select mapeado para portas lógicas e o Bloco A1CSA. . . . . . . . p. 37
4.1 Bloco CLA dividido em vários módulos. . . . . . . . . . . . . . . . . . . . . p. 41
4.2 Add-One Select e Bloco A1CSA para o Hierarchical Add-One Carry-Select
Adder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 42
4.3 Carry-Lookahead Adder com o Carry-in fixado em 0. . . . . . . . . . . . . . p. 43
4.4 Esquemático do Hierarchical Add-One Carry-Select Adder descrito para 16
bits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 44
4.5 Carry-Ripple Adder descrito para 16 bits. . . . . . . . . . . . . . . . . . . . p. 44
4.6 Carry-Select Adder descrito para 16 bits. . . . . . . . . . . . . . . . . . . . . p. 45
4.7 Esquema de verificação funcional. . . . . . . . . . . . . . . . . . . . . . . . p. 46
4.8 Full-Adder de CMOS complementar [Rabaey, Chandrakasan e Nikolic 2003]. p. 47
5.1 Atraso crítico dos somadores para os blocos básicos. . . . . . . . . . . . . . p. 49
5.2 Consumo de potência dos somadores para os blocos básicos. . . . . . . . . . p. 50
5.3 Área dos somadores para os blocos básicos. . . . . . . . . . . . . . . . . . . p. 51
5.4 Power-Delay Product dos somadores para os blocos básicos. . . . . . . . . . p. 52
5.5 Consumo de potência por unidade de área dos somadores para os blocos básicos. p. 53
5.6 Atraso crítico dos somadores. . . . . . . . . . . . . . . . . . . . . . . . . . . p. 55
5.7 Atraso crítico normalizado dos somadores. . . . . . . . . . . . . . . . . . . . p. 56
5.8 Razão entre o atraso crítico dos somadores. . . . . . . . . . . . . . . . . . . p. 57
5.9 Consumo de potência dos somadores. . . . . . . . . . . . . . . . . . . . . . p. 58
5.10 Consumo de potência normalizado dos somadores. . . . . . . . . . . . . . . p. 59
5.11 Razão entre o consumo de potência dos somadores. . . . . . . . . . . . . . . p. 61
5.12 Área dos somadores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 62
5.13 Área normalizada dos somadores. . . . . . . . . . . . . . . . . . . . . . . . p. 63
5.14 Razão entre a área dos somadores. . . . . . . . . . . . . . . . . . . . . . . . p. 64
5.15 Power-Delay Product dos somadores. . . . . . . . . . . . . . . . . . . . . . p. 65
5.16 Consumo de potência por unidade de área dos somadores. . . . . . . . . . . . p. 68
Lista de Tabelas
2.1 Exemplo de soma binária. . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 22
2.2 Tabela Verdade para a operação de soma com um Half-Adder (HA). . . . . . p. 23
2.3 Tabela Verdade para a operação de soma com um Full-Adder (FA). . . . . . . p. 24
3.1 Propriedade 1 para adicionar 1 a uma soma. . . . . . . . . . . . . . . . . . . p. 33
3.2 Propriedade 2 a adicionar 1 a uma soma. . . . . . . . . . . . . . . . . . . . . p. 33
3.3 Propriedade 3 para adicionar 1 a uma soma. . . . . . . . . . . . . . . . . . . p. 34
5.1 Atraso crítico dos somadores para os blocos básicos (ps). . . . . . . . . . . . p. 49
5.2 Consumo de potência dos somadores para os blocos básicos (µW). . . . . . . p. 50
5.3 Área dos somadores para os blocos básicos (µm2). . . . . . . . . . . . . . . . p. 51
5.4 Power-Delay Product dos somadores para os blocos básicos (fJ). . . . . . . . p. 52
5.5 Consumo de potência por unidade de área dos somadores para os blocos bá-
sicos (Wm−2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 53
5.6 Atraso crítico dos somadores (ps). . . . . . . . . . . . . . . . . . . . . . . . p. 54
5.7 Atraso crítico normalizado dos somadores. . . . . . . . . . . . . . . . . . . . p. 55
5.8 Razão entre o atraso crítico dos somadores. . . . . . . . . . . . . . . . . . . p. 56
5.9 Consumo de potência dos somadores (µW). . . . . . . . . . . . . . . . . . . p. 58
5.10 Consumo de potência normalizado dos somadores. . . . . . . . . . . . . . . p. 59
5.11 Razão entre o consumo de potência dos somadores. . . . . . . . . . . . . . . p. 60
5.12 Área dos somadores (µm2). . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 62
5.13 Área normalizada dos somadores. . . . . . . . . . . . . . . . . . . . . . . . p. 63
5.14 Razão entre a área dos somadores. . . . . . . . . . . . . . . . . . . . . . . . p. 64
5.15 Power-Delay Product dos somadores (fJ). . . . . . . . . . . . . . . . . . . . p. 65
5.16 Eficiência energética dos somadores normalizada. . . . . . . . . . . . . . . . p. 66
5.17 Razão entre a eficiência energética dos somadores. . . . . . . . . . . . . . . p. 66
5.18 Consumo de potência por unidade de área dos somadores (Wm−2). . . . . . . p. 67
A.1 Número de transistores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 73
A.2 Número de Células para o Add-One Carry-Select Adder (A1CSA), Hierar-
chical Add-One Carry-Select Adder (A1CSAH) e Carry-Lookahead Adder
(CLA). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 74
A.3 Número de Células para o Carry-Ripple Adder (CRA) e Carry-Select Adder
(CSA). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 75
Lista de Acrônimos
A1 Add-One
A1S Add-One Select
A1CSA Add-One Carry-Select Adder
A1CSAH Hierarchical Add-One Carry-Select Adder
B-A1CSA Bloco A1CSA
B-CLA Bloco CLA
B-CSA Bloco CSA
CI Circuito Integrado
CIN Carry-in
CLA Carry-Lookahead Adder
CMOS Complementary Metal-Oxide Semiconductor
COUT Carry-out
CRA Carry-Ripple Adder
CSA Carry-Select Adder
DC Design Compiler
DUV Somador Sob Verificação
E AND
FA Full-Adder
FPGA Field-Programmable Gate Array
GEN Generate
14
Gb Generate do Bloco
Gh Generate da Hierarquia entre os blocos
GPH Bloco de Ligação na Hierarquia
HA Half-Adder
HDL Hardware Description Language
IC Integrated Circuit
MUX Multiplexador
MUX Multiplexor
OR OR
PDP Power-Delay Product
PROP Propagate
Pb Propagate do Bloco
Ph Propagate da Hierarquia entre os blocos
REF Somador de Referência
RIC Re-computing the Inverse Carry-in
RTL Register Transfer Level
Ci Sinal de Seleção
TSMC Taiwan Semiconductor Manufacturing Company Limited
VHDL VHSIC Hardware Description Language
XOR Exclusive-OR
15
Resumo
O uso de Circuito Integrado (CI) está cada vez mais presente no nosso cotidiano. Muitosdesses dispositivos são alimentados por baterias e, consequentemente, precisam ter um exce-lente compromisso entre atraso crítico e consumo de energia. Usualmente, em um projeto deum CI, prioriza-se o consumo de energia ou o atraso crítico. Esses requisitos normalmente sãoconflitantes, por isso, ao otimizar um há o deterioramento natural do outro.
O somador é uma das unidades aritméticas mais importantes. As operações aritméticasbinárias podem ser derivadas para uma sequência de somas. A importância do somador podecolocá-lo como parte do caminho crítico. Assim sendo, o atraso crítico pode ser reduzido coma introdução de um somador rápido. Contudo, um somador rápido normalmente tem área econsumo de energia maiores do que um somador mais lento. Em geral, quando se reduz umavariável de um somador (área, atraso crítico ou consumo de energia) as outras duas tem umaumento significativo.
Este trabalho propõem uma nova organização para os blocos de 4 bits do Add-One Carry-Select Adder (A1CSA). Essa nova organização é chamada de Hierarchical Add-One Carry-Select Adder (A1CSAH). Tal organização torna-o um dos somadores com o atraso crítico apro-ximadamente o mesmo do Carry-Lookahead Adder (CLA). O carry no A1CSAH é propagadoem tempo logarítmico, da mesma maneira que o carry é propagado no CLA. O A1CSAH é, emmédia, 12% mais rápido do que o CLA, o qual é uma das arquiteturas de somador mais rápida,segundo a literatura.
A segunda contribuição deste trabalho é a otimização do bloco que adiciona 1 do A1CSA.Nos trabalhos correlatos esse bloco precisa de um Multiplexador (MUX) para realizar a seleçãoda soma candidata apropriada. No bloco proposto neste trabalho, a função exercida pelo MUXé absorvida pela porta Exclusive-OR (XOR) preexistente. Com isso, o bloco para adicionar 1proposto é menor do que o existente nos trabalhos correlatos.
Ainda, este trabalho caracteriza os somadores A1CSA, A1CSAH, CLA, CRA e o CSA parauma biblioteca de células da Taiwan Semiconductor Manufacturing Company Limited (TSMC).Eles foram sintetizados logicamente com o auxílio da ferramenta Design Compiler (DC) da Sy-nospys em modo “Topographical”. As arquiteturas dos somadores foram descritas em Verilogpara tamanhos de operandos de 8, 16, 32, 64, 128 e 256 bits.
16
Abstract
Nowadays we are using more Integrated Circuit (IC) in our daily lives. Many of thesedevices are powered by batteries. They therefore need an excellent compromise between per-formance and power consumption. Usually either power comsumption or performance is prio-ritized in a IC project. These requirements are normally conflicting. When one requirement isoptimized the other is affected.
The adder is one of the most important arithmetic circuits. The binary arithmetic operationsaddition, subtraction, multiplication and division can be derived for a sequence of sums. Theimportance of the adder can put it as part of the critical path. Thus, the critical delay can bereduced by substituting a slow adder by a fast one. However, a fast adder typically has area andpower consumption higher than a slower one. In general, when one of the variables of an adder(area, delay or power consumption) is reduced, the other two have a significant increase.
This work proposes a new organization for 4-bit Add-One Carry-Select Adder (A1CSA)blocks. The proposed is called Hierarchical Add-One Carry-Select Adder (A1CSAH). TheA1CSA blocks are arranged in binary tree structure. This arrangement make it one of thefastest adders. The carry is propagated in the A1CSAH faster than A1CSA. The carry inthe A1CSA is propagated the same way that it is propagated in the Carry-Lookahead Adder(CLA). The A1CSAH is, on average, 12% faster than the CLA, which is one of the fastestadder architectures, according to literature.
The second contribution is the optimization of a block that adds one in the A1CSA. Inrelated works, this block needs a Multiplexor (MUX) to perform selection of the appropriatesum. In block proposed in this work, the function of MUX is absorbed by the pre-existingExclusive-OR (XOR) gate. Thus, the block proposed is smaller and fastest than the block inrelated works.
This work characterizes A1CSA, A1CSAH, CLA, Carry-Select Adder (CSA) and Carry-Ripple Adder (CRA) for a Standard-Cells library of Taiwan Semiconductor ManufacturingCompany Limited (TSMC). They have been logically synthesized with the aid of the tool De-sign Compiler (DC) of Synospys in Topographical Mode. The architectures of adders weredescribed in Verilog for operands to 8, 16, 32, 64, 128 and 256 bits.
17
1 Introdução
1.1 A Adição Binária em Hardware
Um somador de n bits é um componente de bloco operacional que adiciona dois números
(A0...n−1 e B0...n−1) de n bits e um Carry-in (CIN) de 1 bit. Ele gera uma soma (S0...n−1) de n
bits e um Carry-out (COUT) de 1 bit. Normalmente, n é referido como sendo o tamanho dos
operandos do somador [Vahid 2008].
A adição é uma operação primitiva presente em praticamente todos os Circuito Integrados
(CIs) [Rabaey, Chandrakasan e Nikolic 2003]. Como consequência, o atraso crítico de um cir-
cuito aritmético depende fortemente da maneira como o carry é propagado no somador [Des-
champs, Bioul e Sutter 2006]. Não obstante, as operações aritméticas binárias subtração, mul-
tiplicação e divisão podem ser derivadas para uma sequência de soma binária [Takagi et al.
2007].
Há diversas formas de implementar um somador binário. O Carry-Ripple Adder (CRA) é
a forma fatorada de implementar a adição binária. Assim sendo, ele apresenta a menor área
e o menor consumo de energia. Contudo, ele tende a ter um atraso crítico maior. O Carry-
Lookahead Adder (CLA) é um dos somadores com o menor atraso crítico. Porém, sua área e
potência sofrem um significativo aumento em relação ao CRA.
O Carry-Select Adder (CSA) é uma proposta para acelerar a propagação do carry em relação
ao CRA. Os operandos são divididos em pequenos segmentos e em cada segmento é computada
duas somas candidatas: uma com o CIN 0 e a outra com o CIN 1. Assim que os resultados
estiverem disponíveis, a soma candidata correta é selecionada. A área e o consumo de energia
do CSA são praticamente o dobro do CRA. Contudo, o atraso crítico do CSA é menor do que o
do CRA.
O Add-One Carry-Select Adder (A1CSA) é uma proposta para otimizar a computação das
somas candidatas do CSA. No A1CSA é realizado uma soma com o CIN 0 e após é adicionado
1 ao resultado. Com isso, tem-se duas somas candidatas. A unidade para adicionar 1 é menor
18
do que um somador. Assim sendo, há a redução da área e do consumo de energia do A1CSA
em relação ao CSA.
A otimização da cadeia de carry proposta nesse trabalho, Hierarchical Add-One Carry-
Select Adder (A1CSAH), utiliza o mesmo procedimento do A1CSA para computar as somas
candidatas, mas propaga o carry muito mais rápido do que o A1CSA. Assim sendo, ele é mais
rápido do que o A1CSA. Não obstante, o A1CSAH também é mais rápido do que o CLA.
1.2 Objetivos
1.2.1 Objetivos Gerais
O objetivo geral deste trabalho é propor implementações do A1CSA em tecnologia Com-
plementary Metal-Oxide Semiconductor (CMOS) para o fluxo de projeto Standard-Cells. No
fluxo de projeto Standard-Cells o código Hardware Description Language (HDL) é mapeado
automaticamente e sem dimensionamento de transistores para uma biblioteca Standard-Cells.
1.2.2 Objetivos Específicos
Este trabalho tem como objetivos específicos:
• Propor otimizações na cadeia de propagação do carry do somador A1CSA visando sua
implementação em um fluxo de projeto baseado em Standard-Cells.
• Avaliar a área, o atraso crítico, a potência e a eficiência energética dos somadores CRA,
CLA, CSA, A1CSA e A1CSA com cadeia de propagação de carry otimizada (A1CSAH),
quando implementados em Standard-Cells utilizando uma biblioteca comercial em tec-
nologia CMOS estado da arte (45nm).
1.3 Escopo deste Trabalho
As arquiteturas de somadores que são objeto deste trabalho foram descritas em lingua-
gem Verilog. Elas foram sintetizadas para uma biblioteca Standard-Cell comercial de 45 nm
utilizando a ferramenta Design Compiler em modo Topographical da empresa Synopsys. As
estimativas de área, atraso crítico e potência geradas pelo Design Compiler foram utilizadas
para estabelecer comparações entre as arquiteturas de somadores.
19
1.4 Projeto de Circuitos Integrados Customizados e Metodo-logia de Projeto Baseado em Células (Cell-Based Design)
1.4.1 Projeto de Circuitos Integrados Customizados
Desenhar o circuito integrado manualmente parece ser a única opção quando o atraso crítico
ou a densidade do projeto são os requisitos principais. Essa metodologia era a única opção
quando os circuitos integrados foram introduzidos. A característica de trabalho intensivo ao
projetar circuitos integrados customizados traduz-se em alto custo econômico e longo time-
to-market. Contudo, ele pode ser justificado economicamente sobre as seguintes condições
[Rabaey, Chandrakasan e Nikolic 2003]:
• Um bloco do circuito integrado pode ser reusado muitas vezes [Rabaey, Chandrakasan e
Nikolic 2003].
• O custo econômico do projeto customizado pode ser amortizado sobre uma produção em
larga escala [Rabaey, Chandrakasan e Nikolic 2003].
• O custo econômico não é o principal critério de projeto [Rabaey, Chandrakasan e Nikolic
2003].
O progresso contínuo em projeto automatizado reduziu o compartilhamento de partes de
circuitos integrados customizados. Nos mais avançados processadores de alta performance,
usualmente, todas as partes são projetadas usando circuitos integrados semi-customizados. So-
mente os módulos do caminho crítico são projetados manualmente. Atualmente, um circuito
integrado projetado manualmente é melhor somente em área do que um circuito integrado pro-
jeta com biblioteca de células. A quantidade de projetos de circuito integrado customizado é
minimo, porém para alguns projeto é indispensável o projeto customizado [Rabaey, Chandra-
kasan e Nikolic 2003].
1.4.2 Metodologia Cell-Based Design
Desde que o projeto customizado de circuitos integrados tornou-se proibitivamente caro,
uma variedade de metodologias de projeto tem sido introduzida para reduzir e automatizar o
processo de projeto dos circuitos integrados. A proposta da metodologia de projeto Cell-Based
é reduzir o esforço de implementação ao reutilizar um conjunto limitado de células de uma
biblioteca. A vantagem dessa metodologia é que as células precisam ser projetadas e verificadas
somente uma vez para uma tecnologia, e elas podem ser reutilizadas inúmeras vezes, assim
20
o custo de projeto é amortizado. A desvantagem é que as restrições da biblioteca reduz a
possibilidade de ajuste fino no projeto do circuito integrado [Rabaey, Chandrakasan e Nikolic
2003].
A abordagem Standard-Cells da metodologia Cell-Based Design é padronizado em nível
de portas lógicas. Uma biblioteca de células contém uma ampla seleção de portas lógicas sobre
uma faixa de fan-in e fan-out. A biblioteca contém portas lógicas para funções básicas, tais
como: inversores, AND/NAND, OR/NOR, XOR/XNOR e flip-flops, e portas lógicas para funções
mais complexas, tais como: AND-OR-INVERTER, MUX, full-adder, comparadores, contado-
res, codificadores e decodificadores. Um projeto é capturado como um esquemático contendo
somente as células disponíveis na biblioteca ou é gerada automaticamente a partir de uma des-
crição com uma linguagem de alto nível. Então, o layout é gerado automaticamente. Esse alto
grau de automação é possível por causa do alto grau de restrições sobre as opções de layout. Na
filosofia Standard-Cells, as células são colocadas em linhas separadas por canais de roteamento.
Assim sendo, todas as células da biblioteca devem ter a mesma altura. Contudo, o comprimento
das células pode variar para acomodar a variação de complexidade entre as células [Rabaey,
Chandrakasan e Nikolic 2003].
A abordagem Standard-Cells tem tornado-se popular e é usada em praticamente todos os
elementos lógicos dos circuitos integrados atuais. A única exceção é quando a extrema alta
performance ou baixo consumo de energia são requisitos ou quando a estrutura funcional do
elemento lógico é regular, como memórias e multiplicadores. O sucesso da abordagem Standar-
Cells pode ser atribuída [Rabaey, Chandrakasan e Nikolic 2003]:
• A melhoria na qualidade do posicionamento e roteamento automático das ferramentas
em conjunto com a disponibilidade de múltiplos níveis de roteamento. Estudos mostram
que a abordagem automática atualmente é igual ou melhor do que o projeto manual para
circuitos complexos e irregulares [Rabaey, Chandrakasan e Nikolic 2003].
• O advento de sofisticadas ferramentas de síntese lógica. A abordagem por síntese lógica
permite que todo o projeto possa ser realizado em alto nível de abstração usando equa-
ções booleanas, máquinas de estado ou linguagens Register Transfer Level (RTL), tais
como: Verilog ou VHSIC Hardware Description Language (VHDL). A ferramenta de
síntese lógica automaticamente traduz essas especificações para uma rede de portas lógi-
cas da biblioteca de células, minimizando para um custo específico como área, consumo
de energia ou atraso crítico [Rabaey, Chandrakasan e Nikolic 2003].
21
1.5 Organização deste Trabalho
Este trabalho está organizado em 6 capítulos. O Capítulo 1 introduz a adição binária e
os objetivos gerais e específicos. O Capítulo 2 revisa as arquiteturas CRA, CLA e CSA. No
Capítulo 3 é apresentado o A1CSA e a proposta, A1CSAH, de propagação rápida do carry,
além da otimização no circuito para adicionar 1. O Capítulo 4 descreve as otimizações para
cada arquitetura na implementação, bem como a maneira de implementar cada somador para
operandos maiores do que 4 bits. No capítulo 4 também são mostradas as restrições impostas à
ferramenta de síntese lógica para evitar que esta descaracterizasse os somadores. O Capítulo 5
apresenta e discute os resultados experimentais. No Capítulo 6 são mostradas as conclusões e
os trabalhos futuros.
22
2 Arquiteturas Básicas de Somadores
2.1 Carry-Ripple Adder
A soma binária adiciona dois operandos (A e B) gerando um resultado S e um bit de excesso
ou transporte, referido como COUT. Usualmente a adição binária é realizada da direita para
a esquerda. Com isso o bit menos significativo é o mais a direita. A Tabela 2.1 mostra a
um exemplo de adição em binário dos números 19 e 14, resultando na soma (S) igual a 1
(00001) e no COUT igual a 1. No exemplo mostrado, o par de bits menos significativo pode
ser operado com um Half-Adder (HA), já os demais pares de bits devem ser operados com um
Full-Adder (FA).
Tabela 2.1: Exemplo de soma binária.
11110- carry
10011 A
01110 B
00001 S
2.1.1 Half-Adder
Um HA é um componente combinacional que adiciona um par de bits de pesos iguais, os
operandos A e B, e gera um bit de soma (S) e um bit de excesso ou transporte (carry), referido
por COUT [Vahid 2008].
A Tabela 2.2 mostra a tabela verdade para a operação de soma com um HA.
23
Tabela 2.2: Tabela Verdade para a operação de soma com um HA.
A B Cout S
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0
Analisando a tabela verdade é possível concluir que o COUT da soma com o HA é o re-
sultado de uma operação AND (E) entre o par de bits dos operandos. A Equação 2.1 mos-
tra como é computado o COUT. O resultado da soma com o HA é o resultado da operação
Exclusive-OR (XOR) entre o par de bits. A Equação 2.2 mostra o cálculo da soma [Hwang
1979, Oklobdzija 2001, Frank 2007, Mesquita 2007].
Cout = A.B (2.1)
S = A⊕B (2.2)
2.1.2 Full-Adder
Um FA é um componente combinacional que adiciona três bits de pesos iguais, os operan-
dos A e B e o CIN, e gera um bit de soma (S) e um bit de excesso ou transporte (carry), referido
por COUT [Vahid 2008].
A Tabela 2.3 mostra a tabela verdade para a operação de soma com um FA.
24
Tabela 2.3: Tabela Verdade para a operação de soma com um FA.
Cin A B Cout S
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1
O COUT é computado de forma fatorada como mostrado na Equação 2.3. Bem como, a
soma é calculada com um XOR do CIN e do par de operandos. A Equação 2.4 mostra o cálculo
do soma em um FA [Hwang 1979, Oklobdzija 2001, Frank 2007, Mesquita 2007].
Cout = A.B+A.Cin +B.Cin (2.3)
S = A⊕B⊕Cin (2.4)
2.1.3 Arquitetura Carry-Ripple Adder
Um Carry-Ripple Adder (CRA) pode ser construído trivialmente conectando-se o COUT
de um FA com o CIN do FA subsequente [Mesquita 2007]. O FA do bit menos significativo
pode ser substituído por um HA quando os operandos não possuem CIN. Teoricamente pode-se
construir um CRA para qualquer tamanho de operandos, desde que seja conectado quantos FA
forem necessários [Hwang 1979, Oklobdzija 2001, Frank 2007, Mesquita 2007]. A Figura 2.1
mostra um CRA de n bits construído com FAs.
Figura 2.1: Carry-Ripple Adder de n bits.
25
O CRA é um dos somadores que consomem menos recursos de hardware e um dos que
consomem menos energia. Contudo, o tempo necessário para produzir a soma e o COUT é
muito maior do que em um somador rápido, pois o atraso crítico em um CRA é dependente do
tamanho dos operandos [Brown e Vranesic 2000]. O CRA é um dos somadores mais lentos, pois
o carry é propagado por todos os FAs. Um FA espera o carry ser propagado por todos os FAs
anteriores para completar a soma e disponibilizar o COUT [Frank 2007]. Consequentemente, a
complexidade assintótica de um CRA para o atraso crítico e área é O(n) [Tyagi 1993].
2.2 Carry-Lookahead Adder
Um somador com propagação do carry em tempo logarítmico foi proposto por [Weinber-
ger e Smith 1958]. Teoricamente, o Carry-Lookahead Adder (CLA) é um dos somadores mais
rápidos, pois o carry é propagado em tempo do logarítmico em relação ao tamanho dos operan-
dos [Oklobdzija 2001].
O atraso crítico do CLA é caracterizado por uma função logarítmica do tamanho dos ope-
randos. Ou seja, no pior caso, o COUT do CLA está disponível em log(n), no qual n é o tamanho
dos operandos. Já no caso do CRA, o COUT está disponível em n, no qual n é o tamanho dos
operandos. No CRA, o carry deve passar por todos os pares de bits dos operandos até estar
disponível. No CLA, o carry não passa por todos os pares de bits dos operandos, pois ele é
computado em paralelo para cada par de bits. Assim sendo, a propagação do carry é acelerada.
A passagem rápida do carry entre cada par de bits dos operandos é realizada com o auxílio
dos sinais de Propagate (PROP) e Generate (GEN). O PROP detecta se um par de bits dos
operandos em qualquer ordem passa o carry para o próximo par de bits. Ele sinaliza que esse
par de bits está apto a passar o carry. A Equação 2.5 mostra como a computação do PROP é
realizada. O sinal de GEN detecta se o par de bits dos operandos em qualquer ordem gera um
carry. A Equação 2.6 mostra como detectar a geração de um carry para cada para de bits dos
operandos. O tempo de computação do PROP e do GEN é constante, independente do tamanho
dos operandos.
Pi = Ai⊕Bi (2.5)
Gi = Ai.Bi (2.6)
Contudo, o carry deve ser passado rapidamente por uma sequência de pares de bits. O CIN
e o PROP e GEN de cada par de bits dos operandos são usados nas equações que mostram como
realizam tal procedimento. As Equações 2.7, 2.8 e 2.9 mostram o cálculo dos carries para o
primeiro, segundo e terceiro par de bits, respectivamente. A computação em paralelo de cada
26
carry para cada par de bits dos operandos evita que ele seja propagado por cada estágio. No caso
do CRA, o carry deve ser propagado por cada estágio de soma. Assim sendo, o respectivo carry
para cada par de bits está disponível em um tempo menor e a operação de adição é acelerada no
CLA. A Equação 2.10 mostra uma generalização para computar o carry para qualquer tamanho
de sequência de pares de bits dos operandos.
C0 = G0 +P0.Cin (2.7)
C1 = G1 +P1.G0 +P1.P0.Cin (2.8)
C2 = G2 +P2.G1 +P2.P1.G0 +P2.P1.P0.Cin (2.9)
Ci−1 = Gi−1 +Pi−1.Gi−2 + ...+Pi−1.Pi−2...P0.Cin (2.10)
A operação de soma é finalizada em qualquer ordem dos operandos com o auxílio do PROP
da mesma ordem e do carry dos pares de bits anteriores. A Equação 2.11 mostra como a soma
é completada no CLA.
Si = Pi⊕Ci−1 (2.11)
Um CLA com o tamanho de operandos maiores do que 4 bits não é viável, pois as restrições
de fan-in e fan-out são violadas. Usualmente, o fan-in máximo é limitado em 5 [Takagi et al.
2007]. O limite de transistores empilhados deve-se a características elétrica dos transistores,
pois o sinal elétrico propagado por um conjunto de transistores empilhado é degradado ao passar
por cada transistor [Rabaey, Chandrakasan e Nikolic 2003]. Assim sendo, limita-se o tamanho
dos operandos do CLA a 4 bits, pois há no máximo 4 transistores empilhado ao implementá-lo.
Um Bloco CLA (B-CLA) é um CLA limitado a operandos de 4 bits. Um B-CLA precisa
passar rapidamente o carry através de sua estrutura. Os sinais de Propagate do Bloco (Pb) e
Generate do Bloco (Gb) realizam tal procedimento. O Pb sinaliza que a sequência de pares
de bits do B-CLA propaga o CIN recebido pelo mesmo. O Gb mostra que um par de bits dos
operandos gerou um carry e este foi propagado dentro do B-CLA até o último par de bits. O
cálculo do Gb e do Pb são mostradas nas Equações 2.12 e 2.13, respectivamente, para um B-
CLA. A Equação 2.14 mostra a computação do COUT quando um B-CLA precisa realizar tal
operação. Quando o tamanho dos operandos é maior do que 4 bits um B-CLA usualmente não
computa o COUT, então essa equação pode ser eliminada. O COUT é computado na lógica
responsável por conectar os B-CLAs quando o tamanho dos operandos é maior do que 4 bits.
27
Gb = G3 +P3.G2 +P3.P2.G1 +P3.P2.P1.G0 (2.12)
Pb = P3.P2.P1.P0 (2.13)
Cout = Gb +Pb.Cin (2.14)
A Figura 2.2 mostra um B-CLA de 4 bits com a função de COUT. As Equações 2.5, 2.6,
2.7, 2.8, 2.9, 2.11, 2.12, 2.13 e 2.14 foram mapeadas para portas lógicas E, OR (OR) e XOR.
Figura 2.2: Carry-Lookahead Adder de 4 bits.
A maneira com a qual os B-CLAs são conectados faz com que o carry seja passado rapi-
damente através deles. Normalmente, eles são conectados em formato de árvore binária. Com
isso o carry é passado em log(n), pois nessa arquitetura a dependência da cadeia de carry é
quebrada, portanto um B-CLA não precisa esperar a propagação do carry pelo B-CLA anterior
para realizar a adição. A característica de log(n) deve-se ao fato de aumentar em um nível de
lógica extra, aumentar em um nível a altura lógica que o carry deve passar, ao dobrar o tamanho
dos operandos no CLA. Os B-CLAs também podem ser conectados ligando o COUT de um
com o CIN do B-CLA seguinte. Contudo, essa maneira de conectar aumenta o atraso crítico
do CLA, pois nesse caso há a dependência do carry estar pronto no B-CLA anterior para que o
B-CLA atual possa propagá-lo para o próximo B-CLA.
A conexão entre os B-CLAs precisa de lógica extra, que computa o Generate da Hierarquia
entre os blocos (Gh) e o Propagate da Hierarquia entre os blocos (Ph). O Ph sinaliza que o
28
carry está sendo propagado. O Gh sinaliza que um carry foi gerado e este foi propagado. A
Figura 2.3 mostra o mapeamento em portas lógicas E e OR do CLA de 16 bits em formato de
árvore binária. O Bloco de Ligação na Hierarquia (GPH) conecta dois B-CLAs ou dois GPHs.
A maneira de conectar utilizando B-CLAs e GPHs pode ser estendida para construir somadores
com o tamanho dos operandos maior.
Figura 2.3: Carry-Lookahead Adder hierárquico de 16 bits.
O GPH é responsável por computar o carry para o B-CLA dos bits de maior ordem ou
calcular o carry para o GPH dos bits de maior ordem. Ele também é responsável por calcular o
Ph, o Gh e no último nível de hierarquia o COUT. A Equação 2.15 descreve como computar o
carry (C1) para o B-CLA1 no GPH10. Por sua vez, na Equação 2.16 é mostrado como calcular o
Ph10 e na Equação 2.17 é mostrado como calcular o Gh10 para o GPH10, respectivamente. Para
o GPH11, as Equações 2.18, 2.19 e 2.20 descrevem como computar, respectivamente, o C3 para
o B-CLA3, o Ph11 e o Gh11.
C1 = Gb00 +Pb00.Cin (2.15)
Ph10 = Pb00.Pb01 (2.16)
29
Gh10 = Gb01 +Pb01.Gb00 (2.17)
C3 = Gb02 +Pb02.C2 (2.18)
Ph11 = Pb02.Pb03 (2.19)
Gh11 = Gb03 +Pb03.Gb02 (2.20)
O GPH20, último nível da hierarquia no exemplo mostrado na Figura 2.3, deve computar
também o COUT. As Equações 2.21, 2.22 e 2.23 mostram como computar o C2 para o B-CLA2,
o Ph20 e o Gh20, respectivamente. Esse bloco também deve computar o COUT como mostrado
na Equação 2.24.
C2 = Gh10 +Ph10.Cin (2.21)
Ph20 = Ph10.Ph11 (2.22)
Gh20 = Gh11 +Ph11.Gh10 (2.23)
Cout = Gh11 +Ph11.Gh10 +Ph11.Ph10.Cin (2.24)
O atraso crítico do CLA não é diretamente proporcional ao tamanho dos operandos, mas ao
número de níveis usados na hierarquia, ou seja, ao número total de níveis de GPHs. Por causa
disso, a função assintótica que caracteriza o atraso crítico é O(log n) e a que caracteriza a área
é O(nlog n) [Oklobdzija 2001, Tyagi 1993].
2.3 Carry-Select Adder
O atraso crítico de um CRA pode ser reduzido particionando-o em blocos. Cada bloco
computa duas somas candidatas, uma com o CIN fixado em 0 e a outra com o CIN fixado em
1. Então, seleciona-se a soma correta a partir do CIN para o bloco [Takagi et al. 2007, Bedrij
1962].
Um Bloco CSA (B-CSA) é composto por dois somadores, um com o CIN fixado em 0 e
o outro com o CIN fixado em 1, e por um Multiplexador (MUX). Usualmente o tamanho dos
operandos é limitado a 4 bits em um B-CSA, uma vez que operandos com tamanho grande
podem ocasionar aumento demasiado no atraso crítico.
A adição com operandos extensos precisa que os B-CSAs sejam conectados de alguma
maneira. A conexão entre eles é realizada com lógica extra, que computa o Sinal de Seleção (Ci)
para cada bloco. O carry no CSA é propagado pela lógica extra. As Equações 2.25, 2.26 e 2.27
30
mostram como calcular o Ci para os três primeiros B-CSAs, respectivamente. Uma Equação
genérica para computar o Ci de um B-CSA em qualquer ordem é mostrada em 2.28.
C0 =Cin (2.25)
C1 =C03 +(C13.Cin) (2.26)
C2 =C07 +(C17.(C03 +(C13.Cin))) (2.27)
Cn =C0n +(C1n.(C0(n−1)+(C1(n−1).(...(C07 +(C17.(C03 +(C13.Cin)))))))) (2.28)
A Figura 2.4 mostra um CSA de 16 bits composto por quatro B-CSAs. A lógica extra pro-
paga o carry para cada B-CSA e também para o COUT da adição. A complexidade assintótica
de um CSA em relação ao atraso crítico é O(n) [Rabaey, Chandrakasan e Nikolic 2003]. A
complexidade assintótica do CSA é igual a do CRA. Contudo, no CSA o carry não passa por
cada par de bits dos operandos, ele passa por um circuito dedicado que é mais rápido.
A unidade somadora de um B-CSA pode ser um CRA quando o consumo de energia é o
fator principal, senão ela pode ser substituída por um CLA quando o atraso crítico é o ponto
principal [Rawat, Darwish e Bayoumi 2002].
Figura 2.4: Carry-Select Adder de 16 bits.
31
3 Add-One Adders
O Somador Add-One é uma arquitetura em que uma soma é realizada com o CIN fixo em 0.
Quando esta soma está pronto é adicionado 1 com um circuito dedicado. Este circuito é menor,
consome menos potência e mais rápido do que um somador. No somador Add-One há duas
somas candidatas, uma operada com o CIN igual a 0 e a outra computada com o CIN igual 1.
Ao adicionar 1 a uma soma realizada com um somador e CIN igual a 0 tem-se o mesmo efeito
de ter computado os operandos com um somador e CIN igual a 1. A decisão de qual soma
candidata, a soma com CIN igual 0 ou a com CIN igual a 1, e baseada no carry. Se o carry for
igual a 0, a soma realizada pelo somador é a correta, senão a soma que foi adicionado 1 com o
circuito dedicado é a correta.
3.1 Add-One Carry-Select Adder
A computação de uma soma com CIN fixo em 0 e a adição de 1 a este resultado foi proposto
por [Chang e Hsiao 1998]. Este modo de realizar adição binária foi chamado de Add-One. Não
obstante, foram propostas melhorias para esse somador por [He, Chang e Gu 2005, Kim e Kim
2001a, Kim e Kim 2001b, Rawat, Darwish e Bayoumi 2002, yan, Xin e Xi 2008, yan, Xin e Xi
2008]. Contudo, todas essas melhorias foram baseadas em projeto em nível de transistor.
A implementação do A1CSA em HDL foi realizada por [Mesquita 2007, Mesquita et al.
2007, Mesquita et al. 2008]. Porém, ele foi sintetizado para Field-Programmable Gate Ar-
ray (FPGA). O A1CSA é chamado de Re-computing the Inverse Carry-in (RIC) pelo autor.
Contudo, o nome do somador foi trocado ao referenciar esses trabalhos nesta seção, pois os
demais trabalhos correlatos referenciam o RIC como A1CSA.
O CSA não é uma implementação otimizada para “select adders”, pois ele realiza duas
adições para depois decidir qual é a correta. Uma análise das propriedades da soma binária
mostra que um dos somadores não é necessário, pois a diferença entre os resultados (com CIN
igual a 0 e CIN igual a 1) no CSA é de apenas 1. Com isso, uma forma mais eficiente de projetar
um Select-Adder é realizar a soma com CIN fixado em 0 e adicionar 1 quando a soma estiver
32
pronta.
O A1CSA faz uso de um somador e uma unidade Add-One (A1). Esta unidade realiza a
mesma função de um somador e ainda é menor [Mesquita 2007,Mesquita et al. 2007,Mesquita
et al. 2008]. A Figura 3.1(a) apresenta a arquitetura de um somador A1CSA de 4 bits e a
Figura 3.1(b) mostra o A1 mapeado para portas lógicas. O A1 é ligado em série com a saída
do somador. O objetivo principal do circuito A1 é completar a soma quando o CIN é igual
a 1, pois o somador somente opera com o CIN fixado em 0 [Mesquita 2007, Mesquita et al.
2007, Mesquita et al. 2008].
(a) A1CSA de 4 bits. (b) A1 Block.
Figura 3.1: Add-One Carry-Select Adder e Add-One Block para 4 bits.
A adição de 1 a uma soma já existente depende de três propriedades. Elas determinam as
posições que devem ser alteradas. Essas propriedades garantem que adicionar 1 a uma soma
realizada como CIN igual a 0 é equivalente a realizar a mesma adição, mas com o CIN igual a
1.
Propriedade 1. Dados dois números a serem somados, se ambos os números possuírem o
bit menos significativo igual a 0, o resultado da soma destes números com CIN igual a 1 é
idêntico ao resultado da soma com CIN igual a 0, exceto pela inversão do valor do bit menos
significativo do resultado [Mesquita 2007].
A Tabela 3.1 mostra um exemplo numérico da Propriedade 1. Os números 12 e 4 são
somados em binário com o CIN distinto. O bit menos significativo da adição com CIN igual a
0 é o oposto da soma com CIN igual a 1.
33
Tabela 3.1: Propriedade 1 para adicionar 1 a uma soma.
Cin 0 Cin 1
A 01100 (12) A 01100 (12)
B 00100 (4) B 00100 (4)
S 010000 (16) S 010001 (17)
Propriedade 2. Se o resultado de uma adição entre dois números com CIN igual a 0 apresenta
o bit menos significativo igual a 1, o resultado da adição destes mesmos dois números, mas
com CIN igual a 1 é equivalente sendo necessária a inversão dos m bits do resultado menos
significativos até que seja encontrado o primeiro 0. Este último também deve ser invertido
[Mesquita 2007].
A Tabela 3.2 mostra um exemplo da Propriedade 2. Os números 17 e 6 são somados em
binário com o CIN distinto. Os 4 bits menos significativos da adição com CIN igual a 1 estão
invertidos em relação aos mesmos bits da soma com CIN igual a 0.
Tabela 3.2: Propriedade 2 a adicionar 1 a uma soma.
Cin 0 Cin 1
A 10001 (17) A 10001 (17)
B 00110 (6) B 00110 (6)
S 010111 (23) S 011000 (24)
Propriedade 3. Dois somadores idênticos recebendo os mesmos operandos de entrada, porém
com carries de entrada distintos, exibem o mesmo carry de saída, exceto quando o AND lógico
entre todos sinais propagate dos somadores resulta em um valor igual a 1 [Mesquita 2007].
Um exemplo para a Propriedade 3 é apresentado na Tabela 3.3. O COUT é diferente quando
dois números (17 e 14) são somados em binário com o CIN distinto, pois todos os pares de bit
dos operandos propagam o carry.
34
Tabela 3.3: Propriedade 3 para adicionar 1 a uma soma.
Cin 0 Cin 1
A 10001 (17) A 10001 (17)
B 01110 (14) B 01110 (14)
S 011111 (31) S 100000 (32)
Contudo, a soma de dois números com o CIN distinto pode gerar o mesmo COUT. Para
isso, pelo menos um dos pares de bit dos operandos não propaga o carry. A Tabela 3.2 mostra
um exemplo em que o COUT é igual ao somar os números 1 e 6 com o CIN distinto.
Baseada nas Propriedades 1 e 2, deriva-se as equações que mostram como adicionam 1 ao
resultado de um somador com o CIN fixado em 0. As Equações 3.1, 3.2, 3.3 e 3.4 descrevem
como realizam tal operação para os 4 bits menos significativos [Mesquita 2007]. Não obstante,
uma equação genérica é mostrada em 3.5.
S0 = R0 (3.1)
S1 = R0⊕R1 (3.2)
S2 = (R0.R1)⊕R2 (3.3)
S3 = (R0.R1.R2)⊕R3 (3.4)
Sn = (R0.R1.R2...Rn−1)⊕Rn (3.5)
A Equação 3.6, derivada da Propriedade 3, mostra como detectar se todos os pares de bit
dos operandos propagam o carry.
Pb = (A0⊕B0).(A1⊕B1).(A2⊕B2).(A3⊕B3) (3.6)
As funções para somar 1 implementadas em CMOS são limitadas a 4 bits, pois as restrições
de fan-in e/ou fan-out podem ser violadas para operandos extensos [Takagi et al. 2007]. Com
isso, somente as Equações 3.1, 3.2, 3.3 e 3.4 são utilizadas. A Figura 3.1(b) mostra essas
equações mapeadas para portas lógicas no A1.
Um Bloco A1CSA (B-A1CSA), mostrado na Figura 3.2, possui um somador como CIN
fixado em 0, um A1 e um MUX. O somador computa os operandos e o A1 adiciona 1 ao
resultado. O MUX seleciona com base no Ci (CIN) de cada bloco o resultado apropriado.
35
Figura 3.2: Bloco Add-One Carry-Select Adder.
A adição de operandos extensos precisa de vários B-A1CSAs interligados. A conexão entre
eles é realizada com lógica extra, a qual computa o Ci para cada bloco. As Equações 3.7, 3.8, 3.9
e 3.10 descrevem como computar os Cis para os quatro primeiros B-A1CSAs, respectivamente.
Consequentemente, a equação genérica 3.11 mostra como calcular o Ci para um B-A1CSA em
qualquer ordem. O COUT para a adição dos operandos é a computação do Ci de todos os
B-A1CSAs.
C0 =Cin (3.7)
C1 =C03 +(Pb0.Cin) (3.8)
C2 =C07 +(Pb1.(C03 +(Pb0Cin))) (3.9)
C3 =C015 +(Pb2.(C07 +(Pb1.(C03 +(Pb0.Cin))))) (3.10)
Cn =C0n +(Pbn + ...+C015 +(Pb2.(C07 +(Pb1.(C03 +(Pb0.Cin))))))) (3.11)
A Figura 3.3 mostra um A1CSA de 16 bits. A conexão entre os B-A1CSAs é realizada
através de uma única equação que mostra como computar os Cis e o COUT. A lógica extra
propaga a cadeia carry no A1CSA. As equações que descrevem como computar os Cis possuem
lógica em comum que pode ser fatorada.
36
Figura 3.3: Add-One Carry-Select Adder de 16 bits.
3.2 Hierarchical Add-One Carry-Select Adder
O A1CSAH é uma proposta de arquitetura somadora para o transporte rápido do carry. A
passagem rápida do carry está relacionada à arquitetura do somador, ou seja, a forma como os
B-A1CSAs estão organizados.
Figura 3.4: Hierarchical Add-One Carry-Select Adder de 16 bits.
37
Os B-A1CSAs no A1CSAH são conectados em formato de árvore binária, com isso o carry
é transportado em tempo de log(n). A estrutura de um A1CSAH é igual a de um CLA, exceto
pelo bloco básico, o qual é um B-A1CSA. A maneira hierárquica de conectar os B-A1CSAs
é a primeira contribuição deste trabalho. A Figura 3.2 mostra a arquitetura proposta para um
A1CSAH de 16 bits.
A segunda contribuição deste trabalho é a otimização do A1. A função exercida pelo MUX
pode ser absorvida pela XOR em cada bit de soma. Porém, as Equações 3.1, 3.2, 3.3, 3.4 e 3.5
devem ser modificadas para refletir tal mudança. Assim sendo, as Equações 3.12, 3.13, 3.14,
3.15 e 3.16 descrevem como adicionar 1 somente quando necessário, pois a XOR é usada como
um inversor controlado. O CIN, sinal usado para seleção das somas candidatas no MUX, ajuda
no controle de quais dos bits da soma devem ser adicionado 1 (invertidos). Os bits resultantes
do somador também sinalizam quais deles devem ser invertidos.
S0 =Cin⊕R0 (3.12)
S1 = (Cin.R0)⊕R1 (3.13)
S2 = (Cin.R0.R1)⊕R2 (3.14)
S3 = (Cin.R0.R1.R2)⊕R3 (3.15)
Sn = (Cin.R0.R1.R2...Rn−1)⊕Rn (3.16)
A Figura 3.5(a) mostra o Add-One Select (A1S) mapeado em portas lógicas. A Figura
3.5(b) mostra o esquemático do B-A1CSA com o A1S.
(a) Add-One Select. (b) B-A1CSA com A1S.
Figura 3.5: Add-One Select mapeado para portas lógicas e o Bloco A1CSA.
A organização hierárquica dos B-A1CSAs utiliza os sinais auxiliares Pb e Gb. O B-A1CSA
disponibiliza o Pb, porém ele não computa o Gb. Contudo, o COUT do somador pode ser usado
38
como Gb. A Propriedade 4, apresentada a seguir, garante que o COUT do somador e o Gb são
iguais quando o CIN está fixo em 0.
Propriedade 4. Em um somador com o CIN fixado em 0, o generate do bloco (Gb) é o mesmo
que o COUT do somador.
Entretanto, em alguns casos não é possível obter o Pb a partir de cada par de bit dos operan-
dos. Contudo, ele pode ser obtido a partir do resultado da computação realizada pelo somador,
como mostra a Propriedade 5. Essa propriedade é útil quando não se tem acesso a estrutura
interna do somador. Assim, a computação do Pb não utiliza lógica extra. Contudo, há um pe-
queno aumento no tempo para calculá-lo, pois o Pb é computado somente após o resultado da
adição estar disponível.
Propriedade 5. O AND lógico de cada propagate para cada par de bits dos operandos é igual
ao AND de cada bit de soma em um somador com o CIN fixado em 0.
As Propriedades 4 e 5 são contribuições de menor relevância que as duas primeiras propos-
tas, mas elas são úteis ao implementar um A1CSAH e quando o acesso à unidade somadora do
A1CSAH é restrita, respectivamente. A Propriedade 5 também pode ser aplicada ao projetar
um somador A1CSA.
39
4 Síntese Lógica dos Somadores
4.1 Configuração Experimental
As arquiteturas CRA, CLA, CSA, A1CSA e A1CSAH apresentadas nos Capítulos 2 e 3
foram descritas com a linguagem HDL Verilog. Cada arquitetura somadora foi descrita para
operandos com tamanho de 8, 16, 32, 64, 128 e 256 bits. Este capítulo apresenta os deta-
lhes ao implementar em Verilog cada arquitetura, as otimizações adotadas para cada uma das
arquiteturas e ainda as restrições impostas à ferramenta de síntese lógica a fim de evitar a des-
caracterização dos somadores.
Os somadores foram sintetizados logicamente com a ferramenta Design Compiler (DC)
versão D-2010.03-SP2 da Synopsys. No processo de síntese lógica foi utilizada a biblioteca
de células 45 nm da Taiwan Semiconductor Manufacturing Company Limited (TSMC). Os
resultados para atraso crítico, consumo de energia e área são reportados pela ferramenta de
síntese lógica. Esses dados são reportados com o DC, o qual é uma ferramenta comercial
amplamente utilizada em fluxo para Standard-Cells. Não obstante, o DC possui um modo
chamado Topographical, que segundo os manuais de seu desenvolvedor, utiliza os dados da
simulação elétrica das células ao sintetizar e reportar os dados de um projeto. Os resultados
foram gerados com a ferramenta em tal modo.
A biblioteca de células utilizada da TSMC possui as seguintes características:
• Library Type: Technology, PG pin Based
• Tool Created: A-2007.12-SP1
• Date Created: Fri Nov 13 11:02:22 CST 2009
• Comments: Copyright TSMC
• Library Version: 120
• Time Unit: 1ns
40
• Capacitive Load Unit: 1.000000pf
• Pulling Resistance Unit: 1kilo-ohm
• Voltage Unit: 1V
• Current Unit: 1mA
• Dynamic Energy Unit: 1.000000pJ (derived from V,C units)
• Leakage Power Unit: 1nW
• Bus Naming Style: %s[%d] (default)
• Operating Condition Name: NCCOM
• Library: tcbn45gsbwptc_ccs
• Process: 1.00
• Temperature: 25.00
• Voltage: 0.90
• Interconnect Model: balanced_tree
• Processo CMOS 45 nm.
• Nominal Voltage Threshhold.
• General Purpose non-well biased with UPF.
• Processo de fabricação Typical-Typical para o transistor NMOS e PMOS.
• A biblioteca possui 869 células.
• A células estão distribuídas em: 1 Tap cell + 699 Basic cells + 85 Clock cells + 8 Filler
cells + 24 Multi-voltage cells + 52 ECO cells.
• A síntese lógica utiliza os dados de simulação elétrica em formato CCS.
• A biblioteca com 10 níveis de metal.
41
4.2 Controle do Processo de Otimização no Design Compiler
O DC não mapeia o código HDL diretamente para a biblioteca real de células (TSMC 45
nm), mas para células de uma biblioteca genérica chamada gtech. Essa biblioteca é um for-
mato interno da ferramenta. A seguir, o mapeamento em gtech é otimizado e mapeado para
a biblioteca real de células. No caso dos somadores deste trabalho, a amplitude do processo
de otimização foi limitado. Caso contrário, o processo de otimização descaracterizaria a arqui-
tetura dos somadores. A arquitetura de um somador é descaracterizada quando a ferramenta
desmonta a arquitetura do somador e realiza otimizações sobre a mesma. A descaracterização
ocorre quando a ferramenta fatora um CLA em um CRA, porém essa otimização não é desejada.
Assim sendo, o processo de otimização global (entre módulos diferentes) é restringido, mas
o processo de otimização local (dentro de cada módulo) está habilitado. Com isso, a arquitetura
de cada somador é mantida e as funções de cada módulo são otimizadas. Caso a otimização
global esteja habilitada, a ferramenta fatora as demais arquiteturas para o CRA. O DC possui
duas flags que bloqueiam a otimização global e mantem a otimização local.
O flag set_structure false -design [get_designs *] desabilita a busca de subfunções em di-
ferentes módulos e a fatoração das mesmas. O flag set_ungroup [get_designs *] false evita que
o DC remova ou reduza os níveis de hierarquia. Portanto, a hierarquia construída ao descrever
um somador é preservada, pois o código HDL de submódulos não é copiado para o módulo de
mais alto nível e, consequentemente, os submódulos não são eliminados. A duas flags foram
utilizadas no processo de síntese lógica.
Figura 4.1: Bloco CLA dividido em vários módulos.
As funções de um somador estão separadas em módulos diferentes para evitar a descarac-
42
terização da arquitetura, pois a ferramenta ainda realiza otimização local. Um bloco básico
de uma determinada arquitetura referencia os respectivos módulos da arquitetura. A Figura
4.1 mostra o exemplo de um CLA de 4 bits (B-CLA). As funções dentro de cada retângulo
hachurado são descritas em módulos diferentes, assim o DC não descaracteriza o CLA.
4.3 Somadores Descritos em Formato de Árvore Binária
A conexão dos blocos básicos em formato de árvore binária foi utilizado para as arquiteturas
CRA, CLA e A1CSAH. Com isso, dois somadores são conectados para computar operandos
maiores. Um dos somadores opera sobre os bits de maior ordem e o outro sobre os bits de
menor ordem.
Contudo, a conexão entre duas unidades para as arquiteturas CLA e A1CSAH usa lógica
extra. As funções que conectam dois somadores nessas arquiteturas estão encapsuladas no
GPH. A conexão entre dois CRAs não requer lógica extra, pois o COUT do CRA dos bits de
menor ordem é ligado ao CIN do CRA dos bits de maior ordem.
Assim sendo, um somador de 8 bits é composto de dois blocos básicos e por lógica extra
para conexão quando necessário. Um somador de 16 bits é composto de dois somadores de 8
bits e por lógica extra para conexão quando necessário. Portanto, um somador, com o tamanho
para cada operando de n bits, é composto por dois somadores de n/2 bits e por lógica extra para
conexão quando necessário. O tamanho n dos operandos é uma potência de 2 pertencente aos
números naturais e é maior ou igual a 8 bits. Um dos somadores computa os n/2 bits de menor
ordem e o outro os n/2 bits de maior ordem.
A diferença entre o A1CSAH, CLA e CRA, simplificadamente, é a arquitetura do bloco
básico utilizado por cada um deles, porém o CRA não utiliza o GPH para a conexão.
(a) A1S descrito em Verilog. (b) B-A1CSA para o A1CSAH.
Figura 4.2: Add-One Select e Bloco A1CSA para o Hierarchical Add-One Carry-Select Adder.
43
Na descrição do B-A1CSA sintetizado logicamente foi utilizado o A1S ao invés do A1. A
Figura 4.2(a) mostra a implementação em portas lógica do A1S e a separação de cada equação
em diferentes módulos. A Figura 4.2(b) mostra o esquemático do B-A1CSA para o somador
A1CSAH. O somador utilizado na síntese lógica do B-A1CSA foi um CLA. O CIN desse
somador foi fixado em 0 e as funções dele foram separadas em módulos diferentes. A Figura
4.3 mostra o esquemático do CLA como CIN fixado em 0.
Figura 4.3: Carry-Lookahead Adder com o Carry-in fixado em 0.
A Figura 4.4 mostra a estrutura hierárquica em formato de árvore binária utilizada ao des-
crever um A1CSAH de 16 bits. O CLA utiliza a mesma estrutura, inclusive o mesmo GPH, mas
o B-A1CSA é substituindo por um B-CLA.
44
Figura 4.4: Esquemático do Hierarchical Add-One Carry-Select Adder descrito para 16 bits.
A descrição de um CRA de 16 bits é mostrada pela Figura 4.5. Os módulos são conectados
através dos sinal de CIN e COUT.
Figura 4.5: Carry-Ripple Adder descrito para 16 bits.
45
4.4 Somadores Descritos com os Blocos Básicos em Formatode Cascata
A conexão dos blocos básicos em formato de cascata foi utilizado para as arquiteturas
A1CSA e CSA, ou seja, para cada tamanho de operandos é referenciado quantos blocos básicos
são necessários e não dois somadores com a metade do tamanho dos operandos. A equação que
descrevem como propagar o carry intermediário dificulta o desenvolvimento de uma estrutura
hierárquica.
O A1CSA e o CSA com o tamanho dos operandos de n bits são compostos por d(n/4)-1eblocos básicos e por um CRA. O tamanho n dos operandos é uma potência de 2 pertencente aos
números naturais e é maior que 8 bits.
Os 4 bits menos significativos são computados pelo CRA. Essa otimização reduz a área e
o tempo de operação, pois um CRA de 4 bits é menor e mais rápido do que um bloco básico. A
conexão entre o CRA e entre os blocos básicos é feita através de lógica extra, a qual propaga o
carry.
Um B-CSA sintetizado logicamente possui dois somadores CRA, um com o CIN fixado em
0 e o outro em 1, e quatro MUXs. Porém, um B-A1CSA para o A1CSA possui um CRA com o
CIN fixado em 0 e um A1S.
A Figura 4.6 mostra um CSA de 16 bits. Em um A1CSA são substituídos os B-CSAs, que
estão dentro dos retângulos hachurados, por B-A1CSAs. O COUT (C1x) do somador com CIN
fixado em 1 é substituído pelo Pb computado a partir da soma com CIN igual a 0. A estratégia
de descrição linear pode ser observada nessa figura, a qual não há mais níveis de hierarquia
além dos blocos básicos. O que é bem diferente dos somadores apresentados na seção anterior.
Figura 4.6: Carry-Select Adder descrito para 16 bits.
46
4.5 Verificação Funcional
A verificação funcional é um método usado para demostrar que a funcionalidade desejada é
preservada na descrição HDL de um circuito [Bergeron 2003]. O termo Testbench usualmente
refere-se a um código simulado usado para criar uma sequência predeterminada de estímulos
ou pseudorrandômica e, então, opcionalmente observar as saídas para verificar se o resultado
está correto [Bergeron 2003,Meyer 2003]. O Testbench frequentemente é implementado usando
HDL [Bergeron 2003].
Os somadores implementados neste trabalho foram submetidos à verificação funcional.
Cada somador possui um Testbench, que é composto de um Somador de Referência (REF),
um módulo para leitura dos estímulos, um módulo para escrita dos resultados e dos estímulos
em um arquivo de log e o Somador Sob Verificação (DUV). O REF é um módulo que utiliza o
operador “+” do Verilog para operar sobre os vetores.
A sequência de estímulos para os somadores de 8 bits é a tabela verdade do mesmo. Con-
tudo, o número de estímulos usando a tabela verdade cresce muito rápido, com isso o tamanho
torna-se proibitivo para os arquivos de log e de estímulos e, principalmente, o tempo de verifi-
cação é proibitivo. Os demais somadores foram verificados funcionalmente com um conjunto
de vetores que sensibiliza a ligação entre os blocos básicos. Uma vez que os blocos básicos já
foram testados com a tabela verdade em 8 bits.
A Figura 4.7 mostra o esquema utilizado no Testbench dos somadores. O gerador gera
um vetor de estímulos para o REF e para o DUV. Estes operam sobre o vetor e o verificador
compara se o resultado produzido pelo DUV é igual ao produzido pelo REF, caso afirmativo
os estímulos de entrada, bem como os resultados produzidos pelo somador de referência e pelo
somador sob teste são salvos, senão o verificador emite uma mensagem de erro para o usuário,
bem como os estímulos e os resultados produzidos por ambos os somadores são apresentados.
Figura 4.7: Esquema de verificação funcional.
47
4.6 Provável Esquemático do Full-Adder da Biblioteca
A manipulação das equações de um CRA pode reduzir o número de transistores. Assim é
possível compartilhar a lógica entre os subcircuitos de geração da soma e do carry. As Equações
2.3 e 2.4 foram reorganizadas para as Equações 4.1 e 4.2 que compartilham lógica [Rabaey,
Chandrakasan e Nikolic 2003].
Cout = A.B+B.Cin +A.Cin (4.1)
S = A.B.Cin +C0.(A+B+Cin) (4.2)
O FA presente na biblioteca da TSMC possui 28 transistores. Assim, pode-se inferir um
possível esquemático em nível de transistor para este FA. A Figura 4.8 mostra um esquemático
em nível de transistor de uma FA presente em [Rabaey, Chandrakasan e Nikolic 2003]. Este
mapeamento também possui 28 transistores. Assim, pode-se especular que o FA presente na
biblioteca de células da TSMC possui o mesmo esquemático da Figura 4.8.
Figura 4.8: Full-Adder de CMOS complementar [Rabaey, Chandrakasan e Nikolic 2003].
48
5 Resultados Experimentais
Na Seção 5.1 são apresentados os resultados para os somadores dos blocos básicos. A partir
da Seção 5.2 são apresentados os resultados para os somadores A1CSA, A1CSAH, CLA, CRA
e CSA com operandos de 8 a 256 bits.
5.1 Blocos Básicos Carry-Ripple Adder e Carry-Lookahead Ad-der
O objetivo dos resultados mostrados nessa seção é caracterizar o CLA e o CRA para ope-
randos de 2 a 8 bits. Esses somadores são utilizados como a unidade somadora para o bloco
básico de todas as arquiteturas apresentadas.
A unidade somadora para um bloco básico pode ser um CLA ou um CRA. O CLA é a
unidade somadora recomendável quando o atraso crítico deve ser o menor, enquanto o CRA é
a unidade somadora ideal quando o consumo de energia é o fator principal [Rawat, Darwish e
Bayoumi 2002]. O CLA e o CRA foram descritos para o tamanho de operandos de 2 a 8 bits
variando em 1 bit.
O CLA para um bloco básico de 4 bits é apresentado na Figura 4.1. As funções dentro de
cada retângulo hachurado são implementadas em módulos diferentes. Nos demais tamanhos
de operandos as equações para o CLA foram ajustadas adequadamente. No caso do CRA, foi
conectado a quantidade de FAs necessário para cada tamanho dos operandos.
5.1.1 Atraso Crítico para os Blocos Básicos
A Tabela 5.1 mostra o atraso crítico dos somadores para os blocos básicos. Os dados mos-
tram que o CLA tem o menor atraso crítico para todos os tamanhos de operandos.
Ao comparar as duas unidades somadoras, o CRA é 9,747 ps mais lento do que o CLA para
2 bits. Bem como, a diferença aumenta para 89,894 ps em 8 bits. Ao aumentar em 4 vezes o
49
tamanho dos operandos, a diferença do atraso crítico aumentou em 9,22 vezes. Especialmente
para 4 bits, o CLA é 35,878 ps mais rápido do que o CRA.
Tabela 5.1: Atraso crítico dos somadores para os blocos básicos (ps).
2 bits 3 bits 4 bits 5 bits 6 bits 7 bits 8 bits
CLA 157,453 189,063 212,319 247,087 264,205 291,158 316,519
CRA 167,200 206,392 248,197 287,535 329,196 372,722 406,413
A Figura 5.1 apresenta o atraso crítico dos somadores para os blocos básicos. A diferença
de atraso crítico entre o CRA e o CLA cresce a medida que o tamanho dos operandos aumenta.
O CRA propaga o carry através de todos os pares de bits dos operandos (FAs), porém o CLA
faz a passagem rápida do mesmo entre os pares de bits. Assim, o atraso crítico do CRA é maior
do que o do CLA.
Figura 5.1: Atraso crítico dos somadores para os blocos básicos.
5.1.2 Consumo de Potência para os Blocos Básicos
A Tabela 5.2 mostra o consumo de potência dos somadores para os blocos básicos. O CRA
consome menos potência para todos os tamanhos de operandos.
O CLA consome 1,447 µW de potência a mais do que o CRA para 2 bits. Ainda, o CLA
consome 12,108 µW de potência mais do que o CRA para 8 bits. Ao expandir o tamanho dos
50
operandos para os blocos básicos em 4 vezes, a diferença de consumo de potência aumentou
8,367 vezes. No caso de 4 bits, o CRA consome 2,842 µW de potência a menos do que o CLA.
Tabela 5.2: Consumo de potência dos somadores para os blocos básicos (µW).
2 bits 3 bits 4 bits 5 bits 6 bits 7 bits 8 bits
CLA 7,294 10,601 14,537 19,087 24,365 28,731 35,497
CRA 5,847 8,721 11,695 14,568 17,542 20,516 23,389
A Figura 5.2 mostra o crescimento do consumo de potência com a variação no tamanho
dos operandos. A diferença de consumo de potência entre o CRA e o CLA aumenta com o
crescimento do tamanho dos operandos. O CLA consome mais potência, porque ele usa lógica
extra para acelerar a propagação do carry.
Figura 5.2: Consumo de potência dos somadores para os blocos básicos.
5.1.3 Área para os Blocos Básicos
A Tabela 5.3 mostra a área dos somadores para os blocos básicos. O CLA possui a maior
área entre todos os tamanhos de operandos.
O CLA para 2 bits é 3,881 µm2 maior que o CRA. Bem como, ele é 47,804 µm2 maior que
o CRA para 8 bits. Ao aumentar o tamanho dos operandos em 4 vezes houve um aumento de
12,317 vezes na diferença da área entre os somadores.
51
Tabela 5.3: Área dos somadores para os blocos básicos (µm2).
2 bits 3 bits 4 bits 5 bits 6 bits 7 bits 8 bits
CLA 12,701 21,168 30,870 42,512 54,860 68,267 83,084
CRA 8,820 13,230 17,640 22,050 26,460 30,870 35,280
A Figura 5.3 apresenta a área dos somadores para os blocos básicos. O crescimento da
diferença de área entre os somadores foi maior do que o crescimento da diferença do atraso
crítico e do consumo de potência. A redundância necessária para acelerar a computação do
carry faz com que a área do CLA seja maior do que a do CRA.
Figura 5.3: Área dos somadores para os blocos básicos.
5.1.4 Power-Delay Product para os Blocos Básicos
A Tabela 5.4 mostra o Power-Delay Product (PDP) dos somadores para os blocos básicos.
O PDP mede a eficiência energética de um circuito integrado. A eficiência energética é obtida
multiplicando o atraso crítico pelo consumo de potência. O CLA tem o maior PDP para todos
os tamanhos de operandos.
O CLA é 0,17 fJ menos eficiente energeticamente do que o CRA para 2 bits e 1,729 fJ
menos eficiente do que o CRA para 8 bits. O aumento de 4 vezes no tamanho dos operandos re-
52
sulta em um aumento de 10,170 vezes na diferença de eficiência energética entre os somadores.
No caso de 4 bits, a diferença de eficiência energética é de 0,183 fJ entre eles.
Tabela 5.4: Power-Delay Product dos somadores para os blocos básicos (fJ).
2 bits 3 bits 4 bits 5 bits 6 bits 7 bits 8 bits
CLA 1,148 2,004 3,086 4,716 6,437 8,365 11,235
CRA 0,978 1,800 2,903 4,189 5,775 7,647 9,506
A Figura 5.4 mostra que o crescimento da diferença de PDP entre os blocos básicos é
pequena. O CRA tem o atraso crítico maior, mas o consumo de potência é menor. Por outro
lado, o atraso crítico do CLA é menor, mas o seu consumo de potência é maior. Portanto, a
diferença de eficiência energética entre esses somadores é pequena.
Figura 5.4: Power-Delay Product dos somadores para os blocos básicos.
5.1.5 Consumo de Potência por Unidade de Área para os Blocos Básicos
A Tabela 5.5 mostra o consumo de potência por unidade de área dos somadores para os
blocos básicos. O CLA é o somador que consome menos potência por unidade de área.
O CLA consome 0,089 Wm−2 de potência a menos do que o CRA para 2 bits. Bem como,
o CRA consome 0,236 Wm−2 de potência a mais para 8 bits. Ao aumentar o tamanho dos
53
operandos em 4 vezes houve um aumento de 2,651 vezes na diferença de consumo de potência
por unidade de área entre os somadores.
Tabela 5.5: Consumo de potência por unidade de área dos somadores para os blocos básicos
(Wm−2).
2 bits 3 bits 4 bits 5 bits 6 bits 7 bits 8 bits
CLA 0,574 0,501 0,471 0,449 0,444 0,421 0,427
CRA 0,663 0,659 0,663 0,661 0,663 0,665 0,663
A Figura 5.5 mostra o consumo de potência por unidade de área dos somadores para os
blocos básicos. O CRA consome praticamente a mesma quantidade de potência por unidade
área para todos os tamanhos de operandos, porém o CLA reduz o seu consumo de potência por
unidade de área com o aumento no tamanho dos operandos.
Figura 5.5: Consumo de potência por unidade de área dos somadores para os blocos básicos.
5.2 Atraso Crítico para os Somadores
A Tabela 5.6 mostra o atraso crítico dos somadores analisados neste trabalho. O A1CSAH
tem o menor atraso crítico. Já, o CRA, como era esperado, tem o maior atraso crítico. O CLA é,
em média, 12% mais lento do que o A1CSAH. Esse resultado é significativo, pois a arquitetura
do CLA, segundo a literatura, é uma das que tem o menor atraso crítico.
54
A maior diferença de atraso crítico é entre o A1CSAH e o CRA para todos os tamanhos de
operandos. A diferença para 8 bits é de 117,887 ps, assim como ela aumenta para 9.626,162
ps em 256 bits. Ao aumentar em 32 vezes o tamanho dos operandos houve um aumento na
diferença de atraso crítico entre eles de 81,656 vezes.
O CLA é 46,226 ps mais lento do que o A1CSAH para 8 bits. Assim como, ele é 78,764
ps mais lento do que o A1CSAH para 256 bits. O aumento no tamanho dos operandos em 32
vezes fez a diferença de atraso crítico crescer 1,704 vezes
O CSA é 65,549 ps mais rápido que o A1CSA para 8 bits. Contudo, a partir de 32 bits o
A1CSA é mais rápido do que o CSA. Assim sendo, o A1CSA é 635,144 ps mais rápido em
relação ao CSA para 256 bits.
Tabela 5.6: Atraso crítico dos somadores (ps).
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 359,567 436,701 597,286 888,757 1.546,711 2.857,477
A1CSAH 288,526 356,365 422,749 510,661 597,855 690,281
CLA 334,752 410,495 488,732 573,590 656,810 769,045
CRA 406,413 740,079 1.415,456 2.681,065 5.187,827 10.316,443
CSA 294,018 382,997 616,119 1.032,502 1.849,524 3.492,621
Na Figura 5.6 podem ser observados três conjuntos de funções de atraso crítico distintas.
Um conjunto é formado pelo CRA, que é o somador mais lento de todos. O segundo conjunto é
formado pelo A1CSA e CSA, os quais possuem a diferença no crescimento do atraso crítico en-
tre eles muito próxima. Eles possuem o tempo de computação intermediário entre os somadores
mais rápidos e o mais lento. O último conjunto é formado pelo A1CSAH e CLA. A diferença
no crescimento do atraso crítico destes é a menor entre todos os somadores.
Os três conjuntos de atraso crítico são caracterizados por três funções diferentes. O atraso
crítico do CRA é O(n), já o A1CSAH e o CLA computam em O(log(n)). Assim, o conjunto
intermediário, do A1CSA e do CSA, opera em O(n/4). Portanto, os valores de atraso crítico
para operandos grandes são discrepantes entre os conjuntos, ou seja, a diferença no tempo de
computação tende a crescer entre os conjuntos com o aumento no tamanho dos operandos.
55
Figura 5.6: Atraso crítico dos somadores.
A Tabela 5.7 mostra o atraso crítico de todos os somadores normalizado em relação ao
CRA. Os dados foram obtidos dividindo o atraso crítico dos somadores pelo atraso crítico do
CRA. O A1CSAH é 29% mais rápido do que o CRA para 8 bits e 93,3% mais rápido para
256 bits. Com isso, o A1CSAH de 256 bits pode realizar quase 15 operações enquanto o CRA
realiza apenas 1. O atraso crítico do A1CSA é 11,5% menor do que o do CRA para 8 bits e
72,3% menor para 256 bits. Um A1CSA de 256 bits realiza ao menos 3 operações de adição
enquanto o CRA realiza apenas 1.
Tabela 5.7: Atraso crítico normalizado dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 0,885 0,590 0,422 0,331 0,298 0,277
A1CSAH 0,710 0,482 0,299 0,190 0,115 0,067
CLA 0,824 0,555 0,345 0,214 0,127 0,075
CRA 1,000 1,000 1,000 1,000 1,000 1,000
CSA 0,723 0,518 0,435 0,385 0,357 0,339
A Figura 5.7 ilustra a diferença de atraso crítico dos somadores em relação ao CRA. A partir
de 32 bits, qualquer um dos somadores realiza pelo menos duas operações de adição enquanto
o CRA realiza 1. Porém, somente a partir de 128 bits o A1CSAH e o CLA conseguem realizar
duas operações no tempo em que o A1CSA e o CSA computam 1.
56
Figura 5.7: Atraso crítico normalizado dos somadores.
A Tabela 5.8 mostra a razão do atraso crítico entre os somadores. O atraso crítico do A1CSA
e A1CSAH foi dividido pelo atraso crítico do CLA e CSA. Assim há 4 pares de somadores ao
realizar a comparação. O A1CSAH é 13,8% mais rápido do que o CLA para 8 bits e 10,2%
mais rápido para 256 bits. Em média, o CLA é 11,8% mais lento do que o A1CSAH entre todos
os tamanhos de operandos.
Tabela 5.8: Razão entre o atraso crítico dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits Média
A1CSA/CLA 1,074 1,064 1,222 1,549 2,355 3,716 1,830
A1CSAH/CLA 0,862 0,868 0,865 0,890 0,910 0,898 0,882
A1CSA/CSA 1,223 1,140 0,969 0,861 0,836 0,818 0,975
A1CSAH/CSA 0,981 0,930 0,686 0,495 0,323 0,198 0,602
O A1CSA é 22,3% mais lento do que o CSA para 8 bits. O atraso crítico entre eles reduz
até ficar praticamente empatado em 32 bits. A partir de 64 bits o A1CSA é mais rápido do que
o CSA. Portanto, em 256 bits ele é 18,2% mais rápido do que o CSA. Na média, o atraso crítico
do A1CSA é 2,5% menor do que o do CSA para todos os tamanhos de operandos.
A Figura 5.8 mostra a razão entre o atraso crítico dos somadores. Os pares A1CSA, CSA
e A1CSAH, CLA tem a razão entre os seus atrasos críticos praticamente constante para todos
57
os tamanhos de operandos, pois os somadores de cada par possuem a mesma função de atraso
crítico. A diferença de atraso crítico entre os somadores de cada par é ocasionada por pequenas
mudanças dentro da arquitetura de cada somador. Contudo, nas outras duas possibilidades de
análise (A1CSA, CLA e A1CSAH, CSA) há o crescimento da razão entre o atraso crítico dos
pares avaliados, pois cada somador dentro do par é caracterizado por uma função de atraso
crítico diferente.
Figura 5.8: Razão entre o atraso crítico dos somadores.
5.3 Consumo de Potência para os Somadores
A Tabela 5.9 mostra o consumo de potência dos somadores implementados neste trabalho.
O CRA consome menos potência entre todos os tamanhos de operandos. Contudo, o A1CSAH
é o somador que consome mais potência até 16 bits. Porém, nos demais tamanhos de operandos
o CSA consome mais potência.
O CRA consome 10,93 µW de potência a menos do que o A1CSAH para 8 bits. Bem como,
para 256 bits, ele consome 440,44 µW de potência a menos do que o CSA.
O CLA consome 3,469 µW de potência a menos do que o A1CSAH para 8 bits. Assim
como, para 256 bits ele consome 106,15 µW a menos de potência do que o A1CSAH. A
diferença de consumo de potência entre os somadores aumentou em 30,599 vezes com o cres-
cimento de 32 vezes no tamanho dos operandos.
O A1CSA para 8 bits consome 3,924 µW de potência a menos do que o CSA. Bem como,
ele consome 237,31 µW de potência a menos do que o CSA para 256 bits. Ao aumentar em
58
32 vezes o tamanho dos operandos houve um crescimento de 60,476 vezes na diferença de
consumo de potência.
Tabela 5.9: Consumo de potência dos somadores (µW).
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 26,884 57,165 118,327 238,049 482,490 974,790
A1CSAH 34,319 69,573 137,480 275,395 553,020 1.112,480
CLA 30,850 61,733 123,901 247,334 497,100 1.006,330
CRA 23,389 47,179 95,158 190,016 381,031 771,660
CSA 30,808 68,033 143,884 294,787 600,690 1.212,100
A Figura 5.9 mostra o consumo de potência dos somadores. Eles possuem o crescimento
do consumo de potência muito próximo. A diferença de área entre eles é o principal fator que
influencia na diferença de consumo de potência.
Figura 5.9: Consumo de potência dos somadores.
A Tabela 5.10 apresenta o consumo de potência de todos os somadores normalizado. O
consumo de potência de cada somador foi dividido pelo consumo de potência do CRA. O
A1CSA consome 14,9% a mais de potência do que o CRA para 8 bits. Ainda, o A1CSA
consome 26,3% a mais de potência do que o CRA para 256 bits. O A1CSAH consome 46,7%
mais potência do que o CRA para 8 bits e 44,2% mais potência do que o CRA para 256 bits.
59
Tabela 5.10: Consumo de potência normalizado dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 1,149 1,212 1,243 1,253 1,266 1,263
A1CSAH 1,467 1,475 1,445 1,449 1,451 1,442
CLA 1,319 1,308 1,302 1,302 1,305 1,304
CRA 1,000 1,000 1,000 1,000 1,000 1,000
CSA 1,317 1,442 1,512 1,551 1,576 1,571
A Figura 5.10 ilustra o consumo de potência normalizado para os somadores. Todos eles
consomem mais potência do que o CRA. A diferença de consumo de potência do A1CSAH e
CLA em relação ao CRA ficou praticamente constante entre todos os tamanhos de operandos.
Contudo, houve o aumento do consumo de potência do A1CSA e CSA em relação ao CRA com
a variação no tamanho dos operandos.
Figura 5.10: Consumo de potência normalizado dos somadores.
A Tabela 5.11 mostra a razão de consumo de potência entre os somadores. O consumo de
potência do A1CSA e A1CSAH foi dividido pelo consumo de potência do CSA e CLA. Assim,
são comparados 4 pares de somadores.
O A1CSAH consome 11,2% mais potência do que o CLA para 8 bits e, para 256 bits, ele
consome 10,5% mais potência do que o CLA. Na média, o CLA é 11,3% mais econômico do
60
que o A1CSAH.
O CSA consome 12,7% mais potência do que o A1CSA para 8 bits e consome 19,6% mais
potência do que o A1CSA para 256 bits. Na média, o A1CSA consome 17,5% menos potência
do que o CSA para todos os tamanhos de operandos.
A diferença de consumo de potência entre o A1CSAH e o CLA é praticamente constante
para todos os tamanhos de operandos. Contudo, a diferença de consumo de potência entre o
A1CSA e o CSA aumenta até 32 bits. A partir desse ponto, a diferença de consumo de potência
entre o A1CSA e o CSA é praticamente constante.
Tabela 5.11: Razão entre o consumo de potência dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits Média
A1CSA/CLA 0,871 0,926 0,955 0,962 0,971 0,969 0,942
A1CSAH/CLA 1,112 1,127 1,110 1,113 1,112 1,105 1,113
A1CSA/CSA 0,873 0,840 0,822 0,808 0,803 0,804 0,825
A1CSAH/CSA 1,114 1,023 0,955 0,934 0,921 0,918 0,977
A Figura 5.11 apresenta a razão entre o consumo de potência dos somadores. A razão de
consumo de potência entre os somadores de cada par é praticamente constante com o aumento
do tamanho dos operandos, a exceção ocorre na comparação entre o A1CSAH e o CSA. A
razão decresce com o aumento no tamanho dos operandos. O A1CSAH consome mais potência
do que o CSA até 16 bits. Contudo, para os demais tamanhos de operandos, o CSA consome
mais potência do que o A1CSAH.
61
Figura 5.11: Razão entre o consumo de potência dos somadores.
5.4 Área para os Somadores
A Tabela 5.12 mostra a área de cada somador descrito neste trabalho. O CRA possui a
menor área entre os somadores para todos os tamanhos de operandos. Contudo, a maior área é
do A1CSAH até 64 bits, já para 128 e 256 bits o CSA é o maior somador.
O CRA é 40,396 µm2 menor do que o A1CSAH. Assim como, ele é 1.400,263 µm2 menor
do que o CSA para 256 bits. Ao aumentar em 32 vezes o tamanho dos operandos houve um
aumento de 34,663 vezes na diferença entre o maior e o menor somador.
O CLA é 9,173 µm2 menor do que o A1CSAH para 8 bits. Bem como, ele é 293,529 µm2
menor do que o A1CSAH para 256 bits. O aumento no tamanho dos operandos em 32 vezes
provocou um aumento na diferença de área de 31,999 vezes.
O CSA é 11,642 µm2 maior do que o A1CSA para 8 bits. Não obstante, ele é 733,471 µm2
maior do que o A1CSA para 256 bits. O incremento em 32 vezes no tamanho dos operandos
aumentou a diferença de área em 63 vezes.
62
Tabela 5.12: Área dos somadores (µm2).
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 45,864 102,312 215,208 441,000 892,584 1.795,752
A1CSAH 75,676 153,644 309,582 621,457 1.245,208 2.492,708
CLA 66,503 135,299 272,891 548,075 1.098,443 2.199,179
CRA 35,280 70,560 141,120 282,240 564,480 1.128,960
CSA 57,506 137,239 296,705 615,636 1.253,498 2.529,223
A Figura 5.12 mostra a área dos somadores. O CSA e o A1CSAH possuem praticamente
a mesma área, contudo o A1CSAH é o somador mais rápido, enquanto que o atraso crítico do
CSA é intermediário. O A1CSA é o somador com a menor área depois do CRA.
Figura 5.12: Área dos somadores.
A Tabela 5.13 apresenta a área dos somadores normalizada. A área de cada somador foi
dividida pela área do CRA. O A1CSA é 30% maior do que o CRA para 8 bits. Bem como, para
256 bits ele é 59,1% maior do que o CRA. O A1CSAH é 114,5% maior do que o CRA para 8
bits. Assim como, para 256 bits o CSA é 124% maior do que o CRA. Proporcionalmente ao
CRA, o A1CSAH é o maior somador até 64 bits, após o CSA torna-se o maior em proporção.
Na área do maior somador, para todos os tamanhos de operandos, podem ser colocados 2 CRAs.
63
Tabela 5.13: Área normalizada dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 1,300 1,450 1,525 1,563 1,581 1,591
A1CSAH 2,145 2,178 2,194 2,202 2,206 2,208
CLA 1,885 1,918 1,934 1,942 1,946 1,948
CRA 1,000 1,000 1,000 1,000 1,000 1,000
CSA 1,630 1,945 2,103 2,181 2,221 2,240
A Figura 5.13 ilustra a proporção de área entre os somadores e o CRA. Os somadores
mantêm a proporção, em relação ao CRA, constante com o aumento do tamanho dos operandos.
Contudo, a proporção de área do CSA teve um crescimento significativo para os operandos
menores, mas para o A1CSA a proporção teve um crescimento menor. Esse fenômeno ocorre
por causa da simplificação para os 4 primeiros bits. Porém, para operandos grandes a redução
de área dessa simplificação é praticamente inexpressiva.
Figura 5.13: Área normalizada dos somadores.
A Tabela 5.14 mostra a razão da área entre os somadores. A área do A1CSA e A1CSAH
foi dividida pela área do CLA e CSA, ao total há 4 pares de somadores. Em média o A1CSAH
é 13,5% maior do que o CLA para todos os tamanhos de operandos. O A1CSA é 20,2% menor
do que o CSA para 8 bits. Assim como, ele é 29% menor do que o CSA para 256 bits. O CSA
é 26,6%, em média, maior do que o A1CSA para todos os tamanhos de operandos.
64
Tabela 5.14: Razão entre a área dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits Média
A1CSA/CLA 0,690 0,756 0,789 0,805 0,813 0,817 0,778
A1CSAH/CLA 1,138 1,136 1,134 1,134 1,134 1,133 1,135
A1CSA/CSA 0,798 0,746 0,725 0,716 0,712 0,710 0,734
A1CSAH/CSA 1,316 1,120 1,043 1,009 0,993 0,986 1,078
A Figura 5.11 mostra a razão entre os pares comparados. O A1CSAH e CSA foi o par de
somadores que teve a maior redução de área. O A1CSAH é 31% maior do que o CSA para 8
bits. Contudo, para 256 bits o A1CSAH e o CSA tem praticamente a mesma área. Nos demais
pares de somadores comparados a área manteve-se praticamente constante.
Figura 5.14: Razão entre a área dos somadores.
5.5 Power-Delay Product para os Somadores
A Tabela 5.15 mostra a eficiência energética para os somadores implementados neste tra-
balho. O CRA possui o maior PDP para os tamanhos de operandos a partir de 16 bits. Contudo,
a cada tamanho de operando um somador diferente possui o menor PDP.
O CLA é 0,425 fJ menos eficiente do que o A1CSAH para 8 bits. Bem como, ele é 5,989 fJ
menos eficiente do que o A1CSAH para 256 bits. A diferença de eficiência energética cresceu
65
14,091 vezes com o aumento de 32 vezes no tamanho dos operandos.
O A1CSA é 0,609 fJ menos eficiente do que o CSA para 8 bits e 1.447,966 fJ mais eficiente
do que o CSA para 256 bits. Ao aumentar em 32 vezes o tamanho dos operandos, a diferença
de eficiência energética aumentou em 2.377,612 vezes.
Tabela 5.15: Power-Delay Product dos somadores (fJ).
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 9,667 24,964 70,675 211,568 746,272 2.785,440
A1CSAH 9,902 24,793 58,120 140,633 330,626 767,924
CLA 10,327 25,341 60,554 141,868 326,500 773,913
CRA 9,506 34,916 134,692 509,445 1.976,723 7.960,787
CSA 9,058 26,056 88,650 304,368 1.110,991 4.233,406
A Figura 5.15 mostra a eficiência energética para os somadores. O crescimento do PDP
com o aumento no tamanho dos operandos é significativo. O PDP dos somadores até 64 bits é
praticamente insignificante perto do PDP dos somadores de 128 e 256 bits.
Figura 5.15: Power-Delay Product dos somadores.
O CRA é o somador com o maior PDP entre os somadores com o tamanho dos operandos
grande. O A1CSA e o CSA possui o PDP intermediário. O menor PDP é o dos somadores
A1CSAH e CLA. Assim como no atraso crítico, há a separação dos somadores em conjuntos
de PDP. o atraso crítico dos somadores está dividido em conjuntos e o consumo de potência é
praticamente um único conjunto.
66
Tabela 5.16: Eficiência energética dos somadores normalizada.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 1,039 0,726 0,534 0,413 0,379 0,350
A1CSAH 1,108 0,741 0,450 0,283 0,172 0,097
CLA 1,131 0,743 0,463 0,283 0,169 0,097
CRA 1,000 1,000 1,000 1,000 1,000 1,000
CSA 0,949 0,753 0,661 0,599 0,565 0,530
A Tabela 5.16 apresenta a eficiência energética dos somadores normalizada. O PDP de
cada somador foi dividido pelo PDP do CRA. O CSA é o somador que tem a pior eficiência
energética frente ao CRA a partir de 16 bits. O CSA é, em média, somente 32,4% mais eficiente
do que o CRA para todos os tamanhos de operandos. Por outro lado, o A1CSAH e o CLA são os
somadores mais eficientes energeticamente a partir de 32 bits. O A1CSAH e o CLA são 52,5%
e 53%, respectivamente, mais eficientes, na média, para todos os tamanhos de operandos. Para
tamanhos de operandos até 16 bits eles chegam a ser menos eficiente energeticamente do que
o CRA. Contudo, para operandos maiores do que 16 bits, eles se tornam os somadores mais
eficientes. Eles são 75% mais eficientes do que o CRA, em média, para operandos de 32 a 256
bits. No caso dos operandos de 256 bits, o A1CSAH e o CLA são 91% mais eficientes do que
o CRA.
Tabela 5.17: Razão entre a eficiência energética dos somadores.
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits Média
A1CSA/CLA 0,918 0,978 1,154 1,461 2,242 3,613 1,728
A1CSAH/CLA 0,980 0,998 0,972 1,001 1,017 0,997 0,994
A1CSA/CSA 1,094 0,965 0,808 0,690 0,671 0,661 0,815
A1CSAH/CSA 1,167 0,985 0,681 0,472 0,304 0,182 0,632
A Tabela 5.17 mostra a razão da eficiência energética entre os somadores. O PDP do
A1CSA e A1CSAH foi dividido pelo PDP do CLA e CSA, ao total há 4 pares de somado-
res. Em média, o A1CSAH e o CLA possuem a mesma eficiência energética para todos os
tamanhos de operandos. O A1CSA é 9,4% menos eficiente do que o CSA para 8 bits. Contudo,
a partir de 16 bits o CSA é menos eficiente energeticamente do que A1CSA. Para 256 bits, o
A1CSA é 33,9% mais eficiente energeticamente do que o CSA. Em média, o A1CSA é 18,5%
67
mais eficiente energeticamente do que o CSA para todos os tamanhos de operandos.
5.6 Consumo de Potência por Unidade de Área para os So-madores
A Tabela 5.18 mostra o consumo de potência por unidade de área. O A1CSAH possui o
menor consumo de potência por unidade de área para todos os tamanhos de operandos e o CRA
possui o maior consumo de potência por unidade de área.
O CRA consome 0,209 Wm−2 de potência a mais do que o A1CSAH para 8 bits. Bem
como, ele consome 0,238 Wm−2 de potência a mais do que o A1CSAH para 256 bits. O au-
mento no tamanho dos operandos em 32 vezes incrementou a diferença de consumo de potência
por unidade de área em 1,138 vezes.
A diferença de consumo de potência por unidade de área entre o CLA e o A1CSAH é de
0,010 Wm−2 a mais para o primeiro em 8 bits. Assim como, ela é de 0,012 Wm−2 a menos em
favor do CLA para 256 bits. A diferença de consumo de potência por unidade de área aumentou
em 1,2 vezes.
O A1CSA consome 0,050 Wm−2 de potência a mais do que o CSA para 8 bits. Não
obstante, ele consome 0,064 Wm−2 a mais de potência do que o CSA para 256 bits. Houve
um crescimento de 1,28 vezes na diferença de consumo de potência por unidade de área entre o
CSA e o A1CSA.
Tabela 5.18: Consumo de potência por unidade de área dos somadores (Wm−2).
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 0,586 0,559 0,550 0,540 0,541 0,543
A1CSAH 0,454 0,453 0,444 0,443 0,444 0,446
CLA 0,464 0,456 0,454 0,451 0,453 0,458
CRA 0,663 0,669 0,674 0,673 0,675 0,684
CSA 0,536 0,496 0,485 0,479 0,479 0,479
A Figura 5.16 mostra o consumo de potência por unidade de área dos somadores. Todos os
somadores mantiveram praticamente a mesma relação de consumo de potência por unidade de
área. Porém, o CSA teve uma leve queda no consumo de potência por unidade de área com o
aumento no tamanho dos operandos.
68
Figura 5.16: Consumo de potência por unidade de área dos somadores.
69
6 Conclusões e Trabalhos Futuros
6.1 Conclusões
Neste trabalho, a aceleração da cadeia de carry para o A1CSA foi proposta. No A1CSAH,
proposta para acelerar a cadeia de carry, o carry é propagado em tempo log(n), no qual, n é o
tamanho dos operandos. No A1CSA o carry é propagado em tempo n/4. O A1CSAH foi, em
média, 12% mais rápido do que o CLA para todos os tamanhos de operandos.
Contudo, o A1CSAH consome mais potência do que o somador de referência, o CLA, e é
maior também. A área do CSA e do A1CSAH são praticamente iguais, mas o CSA tem o atraso
crítico intermediário e o A1CSAH é o somador mais rápido entre os analisados. A cada 1%,
em média, de redução no atraso crítico do A1CSAH há um aumento, em média, de 1% na área
e no consumo de potência.
Por outro lado, o A1CSA mostrou-se uma alternativa melhor em relação ao CSA. Ele é mais
rápido, menor e consome menos potência do que o CSA para operandos maiores do que 32 bits.
Assim, o A1CSA se torna uma alternativa muito mais vantajosa do que o seu concorrente por
possuir um melhor compromisso entre o consumo de potência e o atraso crítico.
Uma segunda contribuição deste trabalho foi a otimização do bloco A1 do A1CSA. Com
isso, o bloco A1S, proposta deste trabalho, torna-se mais rápido e menor, contribuindo para
reduzir o atraso crítico do A1CSA ante o CSA.
6.2 Trabalhos Futuros
• Gerar resultados de consumo de potência com atividade de chaveamento baseado na si-
mulação. Neste trabalho foi considerado atividade de chaveamento de 50% sobre cada
transistor, a qual dificilmente é uma atividade de chaveamento real sobre os transistores
de um somador.
• Comparar os resultados do A1CSAH com os somadores Brent-Kung [Brent e Kung],
70
Ling [Ling 1966] e Kogge-Stone [Kogge e Stone 1973]. Esses somadores propagam o
carry em log(n) e, também, limitam o número de conexões entre as portas lógicas.
• Implementar o CSA e A1CSA em formato de raiz quadrada. O primeiro módulo opera
sobre os dois primeiros pares de bits dos operandos, o módulo seguinte opera sobre os
próximos 4 pares de bits dos operandos, o módulo seguinte opera sobre os próximos 8
pares de bits dos operandos, etc.
• Compartilhar a lógica em comum de cada unidade somadora no CSA.
• Caracterizar o A1CSAH com o CRA como a unidade somadora do bloco básico e avaliar
a área, o atraso crítico, a potência e a eficiência energética diante do A1CSAH implemen-
tado neste trabalho e do CLA.
• Mapear os somadores para outros nodos tecnológicos (65 nm, 90 nm, etc).
• Completar o fluxo de projeto CMOS com a síntese física, a verificação formal e a análise
estática de consumo de potência e de atraso crítico.
71
Referências Bibliográficas
BEDRIJ, O. J. Carry-Select Adder. IRE Transactions on Electronic Computers, EC, n. 11, p.340–346, Junho 1962. ISSN 0367-9950.
BERGERON, J. Writing Testbenches: Function Verification of HDL Models. Second edition.New York, NY - USA: Springer, 2003. ISBN 1-4020-7401-8.
BRENT, R. P.; KUNG, H. T. A Regular Layout for Parallel Adders. IEEE Transactions onComputers, v. 31, p. 260–264.
BROWN, S.; VRANESIC, Z. Fundamentals of Digital Logic with VHDL Design. New York,NY, USA: McGraw-Hill, 2000. ISBN 0-07-012591-0.
CHANG, T. Y.; HSIAO, M. J. Carry-Select Adder Using Single Ripple-Carry Adder.Electronics Letters, v. 34, n. 12, p. 2101–2103, Outubro 1998.
DESCHAMPS, J.-P.; BIOUL, G. J. A.; SUTTER, G. D. Synthesis of Arithmetic Circuits:FGPA, ASIC and Embedded Systems. First edition. USA: Wiley-Interscience, 2006. ISBN -13978-0471-68783-2(cloth).
FRANK, H. Uma Inverstigação sobre implementações tolerantes a falhas transientes desomadores Carry-Lookahead e Ripple-Carry em FPGA. Dissertação (Trabalho de Conclusãode Curso) — Universidade Federal de Pelotas, Pelotas-RS, 2007.
HE, Y.; CHANG, C.-H.; GU, J. An Area Efficient 64-bit Square Root Carry-Select Adder forLow Power Applications. IEEE International Symposium on Circuits and Systems, v. 4, p.4082–4085, Maio 2005.
HWANG, K. Computer Arithmetic: Principles, architecture, and design. Purdue University:John Wiley & Sons, 1979. ISBN 0-471-03496-7.
KIM, Y.; KIM, L.-S. A low Power Carry-Select Adder with Reduced Area. IEEE InternationalSymposium on Circuits and Systems, v. 4, p. IV 218 – IV 221, Maio 2001a.
KIM, Y.; KIM, L.-S. 64-bit Carry-Select Adder with Reduced Area. Electronics Letters, v. 37,n. 10, p. 614–615, Maio 2001b.
KOGGE, P.; STONE, H. A Parallel Algorithm for the Efficient Solution of a General Class ofRecurrence Equations. IEEE Transactions on Computers, C-22, p. 783–791, 1973.
LING, H. High Speed Binary Parallel Adder. IEEE Transactions on Electronic Computers,EC-15, p. 799, Outubro 1966.
MESQUITA, E. et al. Arquitetura de Somador de Alto Desempenho Baseada no RecálculoParcial com Carry Invertido. XXXIV Conferencia Latinoamericana de Informática, 2008.
72
MESQUITA, E. et al. RIC Fast Adder and its SET-Tolerant Implementation in FPGAs. IEEEInternational Conference on Field Programmable Logic and Applications, p. 638–641, Agosto2007.
MESQUITA, E. M. Somadores Rápidos Tolerantes a Falhas Transientes Implementados emFPGA. Dissertação (Trabalho de Conclusão de Curso) — Universidade Federal de Pelotas,Pelotas-RS, 2007.
MEYER, A. Principes of Functional Verification. USA: Elsevier, 2003. ISBN 0-7506-7617-5.
OKLOBDZIJA, V. G. Speed VLSI Arithmetic Units: Adders and Multipliers in Design of High-Performance Microprocessor Circuits. USA: IEEE Press, 2001. ISBN 978-0-7803-6001-3.
RABAEY, J. M.; CHANDRAKASAN, A.; NIKOLIc, B. Digital Integrated Circuits: A DesignPerspective. Second edition. USA: Prentice Hall, 2003. ISBN 0-13-090996-3.
RAWAT, K.; DARWISH, T.; BAYOUMI, M. A Low Power and Reduced Area Carry-SelectAdder. The 45th Midwest Symposium on Circuits and Systems, v. 1, p. I 467 – I 470, Agosto2002.
TAKAGI, N. et al. Adders. In: CHEN, W.-K. (Ed.). The VLSI handbook. Second edition. USA:CRP Press - Taylor e Francis Group, 2007. ISBN 0-8493-4199-X.
TYAGI, A. A Reduced-Area Scheme for Carry-Select Adders. IEEE Transactions onComputers, v. 42, n. 10, p. 1163–1169, Outubro 1993.
VAHID, F. Sistemas Digitais: Projeto, Otimização e HDLs. Porto Alegre-Brasil: Artmed,2008. Tradução Anatólio Laschuk. ISBN 978-85-7780-190-9.
WEINBERGER, A.; SMITH, J. L. A Logic for High-Speed Addition. National Bureau ofStandards, v. 591, p. 47–56, 1958.
YAN, S.; XIN, Z.; XI, J. High-Performance Carry-Select Adder Using Fast All-One FindingLogic. Second Asia International Conference on Modeling e Simulation, p. 1012–1014, 2008.
YAN, S.; XIN, Z.; XI, J. Low-Power Carry-Select Adder Using Fast All-One Finding Logic.IEEE International Conference on System of Systems Engineering, p. 1–5, 2008.
73
ANEXO A -- Células da Biblioteca Utilizadas naSíntese Lógica
A Tabela A.1 mostra o número estimado de transistores para cada somador. O manual da
biblioteca possui o gate count de cada célula, com isso é possível estimar o número de transis-
tores de cada somador. As Tabelas A.2 e A.3 apresentam o número de cada célula utilizada por
cada arquitetura de somador. Bem como, o total de células que um somador precisa.
Tabela A.1: Número de transistores.
Somador 8 bits 16 bits 32 bits 64 bits 128 bits 256 bitsA1CSA 72 156 324 660 1332 2676
A1CSAH 121 245 493 989 1981 3965CLA 111 225 453 909 1821 3654CRA 56 112 224 448 896 1792CSA 91 217 469 973 1981 3997
A ferramenta utiliza poucas células distintas da biblioteca ao realizar a síntese lógica. O
A1CSAH é o somador mapeado com o maior número de células diferentes. Por outro lado, o
CRA é o somador com o menor número de células distintas.
Apesar da biblioteca possuir 869 células, das quais 699 poderiam ser utilizadas na síntese
dos somadores. O DC utilizou apenas 17 células distintas para mapear os somadores.
74
Tabe
laA
.2:N
úmer
ode
Cél
ulas
para
oA
1CSA
,A1C
SAH
eC
LA
.
Cél
ula
Gat
eC
ount
Equ
ação
A1C
SAA
1CSA
HC
LA
816
3264
128
256
816
3264
128
256
816
3264
128
256
AN
4D1B
WP
2.5
a.b.
c.d
13
715
3163
24
816
3264
24
816
3264
AN
2XD
1BW
P1.
5a.
b1
37
1531
639
1939
7915
931
99
1939
7915
931
9A
O21
D1B
WP
2a.
b+
c1
11
11
15
1123
4795
191
715
3163
127
255
AO
I32D
1BW
P2.
5a.
b.c+
d.e
48
1632
6412
86
1224
4896
192
CK
MU
X2D
1BW
P3
b.c+
a.b
CK
XO
R2D
0BW
P3
a⊕
b1
37
1531
6316
3264
128
256
512
1632
6412
825
651
5FA
1D0B
WP
7F
ullA
dder
713
2549
9719
3IA
O21
D0B
WP
2(a.b+
c)1
37
1531
63IN
D2D
0BW
P2.
5a.
b2
48
1632
644
816
3264
128
IND
2D1B
WP
2.5
a.b
24
816
3264
24
816
3264
IOA
21D
0BW
P2
a+
b.c
ND
2D0B
WP
1a.
b1
37
1531
632
48
1632
64N
D3D
0BW
P1.
5a.
b.c
13
715
3163
24
816
3264
ND
4D1B
WP
2a.
b.c.
d1
37
1531
632
48
1632
64O
AI2
1D0B
WP
1.5
(a+
b).c
13
715
3163
24
816
3264
OR
2D1B
WP
1.5
a+
bX
NR
2D1B
WP
3a⊕
b2
614
3062
126
48
1632
6412
8To
tal
1844
9620
040
882
452
106
214
430
862
1726
4694
190
382
766
1537
75
Tabe
laA
.3:N
úmer
ode
Cél
ulas
para
oC
RA
eC
SA.
Cél
ula
Gat
eC
ount
Equ
ação
CR
AC
SA8
1632
6412
825
68
1632
6412
825
6A
N4D
1BW
P2.
5a.
b.c.
dA
N2X
D1B
WP
1.5
a.b
13
715
3163
AO
21D
1BW
P2
a.b+
c1
37
1531
63A
OI3
2D1B
WP
2.5
a.b.
c+d.
eC
KM
UX
2D1B
WP
3b.
c+a.
b4
1228
6012
425
2C
KX
OR
2D0B
WP
3a⊕
bFA
1D0B
WP
7F
ullA
dder
816
3264
128
256
1022
4694
190
382
IAO
21D
0BW
P2
(a.b+
c)1
37
1531
63IN
D2D
0BW
P2.
5a.
bIN
D2D
1BW
P2.
5a.
bIO
A21
D0B
WP
2a+
b.c
13
715
3163
ND
2D0B
WP
1a.
bN
D3D
0BW
P1.
5a.
b.c
ND
4D1B
WP
2a.
b.c.
dO
AI2
1D0B
WP
1.5
(a+
b).c
OR
2D1B
WP
1.5
a+
b1
37
1531
63X
NR
2D1B
WP
3a⊕
bTo
tal
816
3264
128
256
1949
109
229
469
949
76
ANEXO B -- Artigo
Hierarchical Add-One Carry-Select Adder
Jucemar Monteiro, José Almada Güntzel
Department of Informatics and Statistics – Federal University of Santa Catarina
Florianópolis, S.C.
{jucemar,guntzel}@inf.ufsc.br
Abstract— This paper proposes a hierarchical add-one carry-select adder architecture optimized for cell-based VLSI generation. The architecture is compared to a previously proposed A1CSA architecture, as well as, to Carry-Select Adder (CSA), Carry-Lookahead, and Carry-Ripple Adder (CRA) architectures. Synthesis results for 45nm technology showed that the proposed A1CSAH architecture is, on average, 10.2% faster than the CLA. Power and area estimates showed that, for all bit-width, the A1CSAH is, on average, 13.5% and 8.5% largest and more power consumption, respectively, than CLA. Power-delay results reveal that, for all bit-width, the A1CSAH has the same energy-efficient than the CLA.
1. Introduction
Addition is the most commonly used arithmetic operation within contemporary electronic systems. It has great importance not only in general purpose CPUs, but also in acceleration blocks, as part of arithmetic circuits. Besides used as a proper operation, it serves as the basis to many other arithmetic operations.
The choice of which adder architecture to use is of utmost importance, since the performance of adders may determine the whole system performance [Rabaey, Chandrakasan and Nikolic 2003]. Area and power consumption are also relevant figures of merit to be considered, especially when the design targets VLSI realization. Recently, energy-efficiency has also become an important metric due to the growth of battery-powered portable device marked.
Most works addressing adder architectures are focused on critical delay reduction by optimizing the carry propagation chain [Rabaey, Chandrakasan and Nikolic 2003], [Ercegovac and Lang 2004], [Oklobdzija 2001]. Such optimization can be accomplished at the logic-level, at transistor-level or at both. Transistor-level optimizations may use pass transistors, dynamic logic, etc. On the other hand, conventional physical design flow relies on standard-cells for layout generation. Although typical standard-cells libraries contain up to hundreds of cells, they are all designed using static CMOS style. The inclusion of user-created cells with other styles, as pass transistor or dynamic logic, is generally not allowed due to limitations of the design flow itself. Therefore, when designing high performance addition-based arithmetic circuits using cell-based VLSI design, designers must rely on logic-level optimized fast adder architectures.
The Add-One Carry-Select Adder (A1CSA) [Chang and Hsiao 1998], [Kim and Kim 2001] has originally been proposed as a low-cost version of the Carry-Select Adder (CSA) [Bedrij 1962]. Later, a low power version of the A1CSA was also proposed [He, Chang and Gu 2005]. However, in order to achieve area/transistor reduction, those
A1CSA circuits, and a few others as well, explore pass transistor logic, which prevents their implementation in a standard-cells design flow. Recently, Mesquita et al. proposed a logic-level only A1CSA architecture, targeting FPGA-based design [Mesquita, Frank, Agostini and Güntzel 2007].
The main contribution of this paper relies on new organization to A1CSA architecture, hereinafter referred to as A1CSAH, specially tailored for standard-cells based design. The A1CSAH was compared to Carry-Ripple Adder (CRA), Carry-Lookahead (CLA), CSA and Mesquita's A1CSA (for the sake of simplicity, referred to as A1CSA). Synthesis results, obtained with Synopsys Design Compiler (DC) [Synopsys 2011], reveal that, for all bit-widths, the A1CSAH is the fastest adder architecture among the investigated ones. They also show that the A1CSAH is as energy-efficient adder architecture as the CLA architecture. Finally, the synthesis results pointed out that, for all bit-width), the A1CSAH is larger and consumes more power than CLA. However, A1CSAH is a few larger and consumes less power than CSA.
The remaining of this paper is organized as follows. Section II presents both A1CSA and A1CSAH architectures and gives a brief review on related works, concerning the A1CSA. Synthesis results are presented and discussed in Section III. Section IV presents the most relevant conclusions of this work.
2. Add-One Carry-Select Adders(A1CSA) for Cell-Based Design
The Carry-Ripple Adder (CRA) is known as the most area efficient, and at the same time, the slowest adder architecture [Ercegovac and Lang 2004. It has both time and area complexities O(n) [Oklobdzija 2001]. In the CSA, addition is divided into m modules of k bits each. The module has two k-bit wide adders (generally, CRAs), which perform two additions at the same time: one with CIN=0 (CIN means carry-in) and another with CIN=1. Such degree of parallelism makes the CSA one of the fastest adder architectures. On the other hand, the CSA area is about as twice as that of the CRA, for a given bit-width. The time and area complexities of the CSA are O(n/4) and O(2n), respectively. In the CLA, the addition is divided into m modules of k bits (usually k=4). The carries within each module are computed in parallel by using “generate” and “propagate” in order to anticipate the module carry out. When CLA modules are connected in hierarchical manner (CLAH), it presents time complexity O(log kn) [Oklobdzija 2001] and area complexity O(nlogn) [Amelifard, Fallah and Pedram 2005].
The philosophy behind the A1CSA relies on optimizing the CSA by replacing the adder with CIN=1 by a less expensive logic, known as "add-one logic". Most works on the A1CSA architecture perform transistor-level optimization on the "add-one logic" by using pass transistors [Chang and Hsiao 1998], [Kim and Kim 2001] [Bedrij 1962]. However, the design at the transistor-level prevents the standard-cells based A1CSA realization. On the other hand, the A1CSA architecture proposed by Mesquita et al. was designed at the logic-level only [Mesquita, Frank, Agostini and Güntzel 2007], to allow FPGA-based synthesis. In this work we consider an adapted version of Mesquita's A1CSA (referred to as A1CSA, simply) which block diagram is showed in Figure 1. In this diagram, the box labeled with "A1" represents the "add-one logic". An explicit multiplexer is responsible for choosing the correct result for each module, except for the least significant one.
(a) (b)
Figure 1. A1 block (a) and A1S block (b)
The add-one logic can be implemented based on the following properties of the binary addition [Kim and Kim 2001], [Mesquita, Frank, Agostini and Güntzel 2007].
Property 1: In an addition of two n-bit numbers with the least significant bit being “0” for both numbers, if the carry-in bit is changed from one value to another, the LSB of the addition is complemented and the other bits remain unchanged.
Property 2: If the addition of two n-bit numbers with a carry-in of “0” has m “1s” before the first occurrence of a “0” (starting from the LSB), then the least significant m+1 bits of the addition with a carry-in of “1” will have values complementary to the first m+1 bits of the addition with carry-in “0”.
Figure 2 shows an example of Properties 1 and 2. Such properties are used to derive the logic equations for the add-one block (A1). The obtained simplified equations are:
Sn = S0n (1)
Sn+1 = S0n ⊕ S0n+1 (2)
Sn+2 = S0n+1 . S0n ⊕ S0n+2 (3)
Sn+3 = S0n+2 . S0n+1 . S0n ⊕ S0n+3 (4)
Example of application of Proprieties 1 and 2 is showed in the Figure 2:
Cin 0 Cin 1
A 1 1 0 0 (12) A 1 1 0 0 (12)
B 0 1 0 0 (4) B 0 1 0 0 (4)
Output 1 0 0 0 0 (16) Output 1 0 0 0 1 (17)
(a)
Cin 0 Cin 1
A 0 0 0 1 (1) A 0 0 0 1 (1)
B 0 1 1 0 (6) B 0 1 1 0 (6)
Output 0 1 1 1 (7) Output 1 0 0 0 (8)
(b)
Figure 2. Example of Property 1 (a) and Property 2 (b)
The properties, showed the Figure 2, were used to derive the circuit for the "add-one logic". Figure 1(a) shows the designed circuit for the "A1" block in Figure 3. (i.e., for the "add-one logic" for A1CSA and A1CSAH).
Analyzing the equations of the A1 block, one can notice that it is possible to incorporate the result selection into the A1 existing XOR gates, therefore eliminating the multiplexer. By doing so, the logic depth of an A1CSA module is reduced, resulting in delay reduction. It also contributes to reduce circuit area, and thus, to improve energy-efficiency. The modified "add-one logic", called A1S, is showed in Figure 1(b). It was used to replace both the A1 block and the multiplexer in the A1CSA of Figure 3.
Figure 3 presents the structure of a 16-bit width version of the proposed A1CSAH. It uses a single CLA per module. However, the carry selection is computed in a hierarchical manner, by a dedicated block called GPH. Similarity to hierarchical CLAs (CLAH), the GPH receives the “propagate” and “generate” of the modules. In the A1CSA and A1CSAH, the block to add-one incorporates the multiplexors.
Figure 3. A1CSAH 16-bit wide
3. Results and Discussions
The analyzed adder architectures A1CSA and A1CSAH were evaluated and compared against CRA, CSA and CLA. CSA is fast “carry select” adder architectures that may be adopted in a cell-based design flow. The CRA was also included in the study to serving as reference.
In order to obtain reliable estimates for area, critical delay and power, 8, 16, 32, 64, 128 and 256-bit wide adders were described in Verilog and synthesized for TSMC 45nm standard-cells library using Synopsys Design Compiler (DC) [Mesquita, Frank, Agostini and Güntzel 2007] in Topographical mode. The DC mapped the CRAs by using the full adder (FA) cell available from the standard-cells library, thus providing the best possible CRA realizations within the automated design flow.
The fast adder architectures were designed by splitting the total bit width into 4-bit wide modules (i.e., m=4). Each output function of block A1 was described in a separated
Verilog module, in order to prevent DC from sharing logic. The same strategy was used to describe block A1S. The CRA adder was also described in a separate Verilog file. The modules were joined in another Verilog module called basic block. Figure 3 shows the 16-bit wide A1CSAH composed by four basic blocks connected in hierarchical manner. CLA was described in the same manner. A1CSA were described in Verilog and is composed by three basic blocks and one 4-bit wide CRA. Such Verilog organization allows to restrict logic optimization and mapping to the bounds of each sub-circuit, thus preventing DC from transforming an A1CSA into a CRA.
Table 1 shows critical delays (in ps) as estimated by Synopsys DC. As it would be expected, the CRA exhibits the worst delay for all bit widths. On the other hand, for 8 bit wide adders the CSA exhibits the shortest delays, whereas for 16 to 256 bit wide adders the A1CSAH exhibits the shortest delays. The delay comparison reveals that the A1CSAH is, on average, 10.8% faster than CLA. A1CSA is 1.7% faster than CSA for 64-bit wide and 18% faster than CSA for 256-bit wide, respectively. On average, A1CSA is 2.1% faster than CSA for all bit width.
Table 1. Critical Delay of Adders [ps]
AdderBit-width
8 16 32 64 128 256
A1CSA 365.87 440.65 608.06 883.52 1550.33 2855.67
A1CSAH 312.93 381.56 453.52 535.33 626.36 706.17
CLA 356.18 430.87 516.22 595.91 685.85 785.18
CRA 406.41 740.08 1415.46 2681.06 5187.83 10316.44
CSA 293.84 386.91 618.76 1037.03 1860.69 3481.57
Table 2 shows area estimates provided by Synopsys DC, in µm2. As one would expect, the CRA requires the smallest amount of area among the investigated architectures. Among the remaining architectures, A1CSAH is the architecture requiring the largest amount of area, followed by CLA for 8-bit wide and CSA for 16 to 32 bit width. The main result of this table is that A1CSAH is, on average, 13.5% largest than CLA for all bit width. A1CSA is, on average, 25.7% smaller than CSA for all bit width.
Table 2. Adders area [µm2]
AdderBit-width
8 16 32 64 128 256
A1CSA 45.86 102.31 215.21 441.00 892.58 1795.75
A1CSAH 75.68 153.64 309.58 621.46 1245.21 2492.71
CLA 66.50 135.30 272.89 548.07 1098.44 2199.18
CRA 35.28 70.56 141.12 282.24 564.48 1128.96
CSA 56.98 135.65 293.00 607.70 1237.09 2495.88
Table 3 shows the power consumption of each adder, expressed in µW, as estimated by Synopsys DC. CRA is the adder architecture requiring the least power. A1CSAH require
more power for 8-bit wide and CSA require more power for 16 to 256 bit width among the adders architecture. A1CSAH consumes, on average, 8.5% more power than CLA for all bit width. A1CSA consumes, on average, 30% less power than CSA.
Table 3. Adders Power Estimates[µW]
AdderBit-width
8 16 32 64 128 256
A1CSA 26.98 1522.10 3142.30 6382.20 12870.40 25841.90
A1CSAH 33.65 2003.90 4039.80 8113.60 16266.50 32558.00
CLA 30.18 1856.40 3746.20 7524.60 15082.10 30203.90
CRA 23.39 1225.00 2450.80 4901.30 9802.60 19612.80
CSA 30.70 2186.80 4695.40 9712.00 19750.70 39823.70
To establish a comparison in terms of energy efficiency, the power-delay product (PDP) of each adder was calculated. The PDP of an adder can be interpreted as the amount of energy it requires to perform each addition. Table 4 shows PDP values in fJ. CSApresents the lowest PDP value for 8-bit wide. A1CSA presents the lowest PDP value for 16-bit wide. A1CSAH presents the lowest PDP for 32 to 256 bit width. CLA presents the higher PDP for 8-bit wide and CRA has the highest PDP among all adders from 16 to 256 bits. A1CSAH is, on average, 3% more energy efficient than CLA for all bit width. A1CSA is, on average, 30.7% more energy efficient than CSA for all bit width.
Table 4. Adders PDP [fJ]
AdderBit-width
8 bits 16 bits 32 bits 64 bits 128 bits 256 bits
A1CSA 9.87 670.71 1910.70 5638.80 19953.34 73795.96
A1CSAH 10.53 764.61 1832.13 4343.43 10188.76 22991.46
CLA 10.75 799.87 1933.86 4483.98 10344.11 23715.38
CRA 9.51 906.60 3469.00 13140.70 50854.19 202334.34
CSA 9.02 846.09 2905.34 10071.67 36749.90 138649.04
5. ConclusionsThis paper presented a version of Add-One Carry-Select Adders suited for cell-based VLSI design flow. This architecture was synthesized for TSMC 45nm standard-cells library by using Synopsys Design Compiler in Topographical mode. Carry-Ripple Adder (CRA), conventional Carry-Select Adder (CSA) and Carry-Lookahead Adder (CLA) were also synthesized. Results showed that A1CSAH requires, on average, 10.8% and 36% less timing than CLA and CSA, respectively. Such timing reduction comes from the hierarchical architecture of A1CSAH.
However, A1CSAH is lager and consumes more power than A1CSA and CLA. In A1CSAH, each 1% of reduction of delay increase 1%, on average, in power consumption and area. The A1CSAh is as energy efficient as CLA, on average, for all bit width. Therefore, the A1CSAH is an excellent high performance and energy-efficient adder alternative for cell-based VLSI design.
7. References
Rabaey, J. M., Chandrakasan, A., and Nikolic, B. (2003) “Digital Integrated Circuits: a design perspective”, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, pp.559-586.
Ercegovac, M. D. and Lang, T. (2004) “Digital Arithmetic”, San Francisco: Elsevier Science.
Oklobdzija , V. (2001) "High-speed VLSI arithmetic units: adders and multipliers", In:Design of High-Performance Microprocessor Circuits, W. J. Bowhill and F. Fox, Eds. Piscataway, N. J.: IEEE Press, pp. 181-204.
Chang, T. Y. and Hsiao, M. J. (1998) “Carry-select adder using single ripple-carry adder”, In: Electronics Letters, vol. 34, no. 22, pp. 2101-2103.
Kim, Y. and Kim, L. S. (2001) “64-bit carry-select adder with reduced area”, ElectronicsLetters, vol. 37, no. 10, pp. 614-615.
Bedrij, O. J. (1962) "Carry-Select Adder", In: IRE Transactions on Electronic Computers, pp. 340-346.
He, Y., Chang, C.-H. and Gu, J. (2005) “An area efficient 64-bit square root carry-select adder for low power applications,” In: IEEE International Symposium on Circuits and Systems (ISCAS2005), pp. 4082–4085.
Mesquita, E., Frank, H., Agostini, L. and Güntzel, José Luís (2007)., “RIC fast adder and its SET-tolerant implementation in FPGAs,” In: International Conference on Field Programmable Logic and Applications (FPL 2007), pp. 638-641.
Synopsys's Design Compiler User Guide (2011), Version C-2009.06.
Amelifard , B., Fallah, F. and Pedram, M. (2005), “Closing the Gap between carry select adder and ripple carry adder: a new class of low-power high-performance adders”, In: ISQED 2005, pp. 148-152
84
AN
EX
OC
--C
ódig
oFo
nte
dosS
omad
ores
(Ver
ilog)
C.1
Cód
igo
Font
edo
Add
-One
Car
ry-S
elec
tAdd
er
C.1
.1C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
8bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
0
//F
ile
Nam
e:
rb0
.v
//F
un
ctio
n:
Add
One
for
Fir
stB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb0
(se
l,s
,rs
);
para
met
ern
=1
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
85
assi
gnrs
=se
l^
s[0
];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
1
//F
ile
Nam
e:
rb1
.v
//F
un
ctio
n:
Add
One
for
Sec
on
dB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb1
(se
l,
s,
rs);
para
met
ern
=2
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0])
^s
[1];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
2
//F
ile
Nam
e:
rb2
.v
//F
un
ctio
n:
Add
One
for
Th
ird
Bit
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb2
(se
l,
s,
rs);
86
para
met
ern
=3
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0]
&s
[1])
^s
[2];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
3
//F
ile
Nam
e:
rb3
.v
//F
un
ctio
n:
Add
One
for
Fo
urt
hB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb3
(se
l,
s,
rs);
para
met
ern
=4
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0]
&s
[1]
&s
[2])
^s
[3];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a
//F
ile
Nam
e:
a1
csa
.v
87
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
a(
sel
,a,b
,s,g
en,p
rop
);
para
met
ern
=4
;
inp
ut
sel
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
wir
e[n−
1:0]
s0,r
s,c
arry
;
hal
f_ad
der
f0(.
a(a
[0])
,.b
(b[0
]),.
s(s
0[0
]),.
cou
t(ca
rry
[0])
);
full
_a
dd
er
f1(.
cin
(ca
rry
[0])
,.a
(a[1
]),.
b(b
[1])
,.s
(s0
[1])
,.co
ut(
carr
y[1
]));
full
_a
dd
er
f2(.
cin
(ca
rry
[1])
,.a
(a[2
]),.
b(b
[2])
,.s
(s0
[2])
,.co
ut(
carr
y[2
]));
full
_a
dd
er
f3(.
cin
(ca
rry
[2])
,.a
(a[3
]),.
b(b
[3])
,.s
(s0
[3])
,.co
ut(
gen
));
rb0
r0(.
sel(
sel
),.
s(s
0[0
]),.
rs(s
[0])
);
rb1
r1(.
sel(
sel
),.
s(s
0[1
:0])
,.rs
(s[1
]));
rb2
r2(.
sel(
sel
),.
s(s
0[2
:0])
,.rs
(s[2
]));
88
rb3
r3(.
sel(
sel
),.
s(s
0[3
:0])
,.rs
(s[3
]));
assi
gnp
rop
=s0
[0]
&s0
[1]
&s0
[2]
&s0
[3];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1c
sa8
bit
s
//F
ile
Nam
e:
a1
csa
8b
its
.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
8b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1
csa
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=8
;
para
met
erm
=2
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
89
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
])
,.p
rop
(pro
p[0
]));
assi
gnco
ut
=ca
rry
[0]
|(p
rop
[0]
&se
l[0
]);
endm
odul
e
C.1
.2C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
16bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a1
6b
its
//F
ile
Nam
e:
a1
csa
16
bit
s.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1
csa
16
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=1
6;
para
met
erm
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
90
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
]),.
pro
p(p
rop
[0])
);
a1cs
aa1
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
])
,.ge
n(
carr
y[1
]),.
pro
p(p
rop
[1])
);
a1cs
aa1
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.ge
n(
carr
y[2
]),.
pro
p(p
rop
[2])
);
assi
gnse
l[1
]=
carr
y[0
]|
(pro
p[0
]&
sel
[0])
;
assi
gnse
l[2
]=
carr
y[1
]|
(pro
p[1
]&
sel
[1])
;
assi
gnco
ut
=ca
rry
[2]
|(p
rop
[2]
&se
l[2
]);
endm
odul
e
C.1
.3C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
32bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a3
2b
its
//F
ile
Nam
e:
a1
csa
32
bit
s.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
32b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1
csa
32
bit
s(c
in,a
,b,s
,co
ut
);
91
para
met
ern
=3
2;
para
met
erm
=8
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
]),.
pro
p(p
rop
[0])
);
a1cs
aa1
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
])
,.ge
n(
carr
y[1
]),.
pro
p(p
rop
[1])
);
a1cs
aa1
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.ge
n(
carr
y[2
]),.
pro
p(p
rop
[2])
);
a1cs
aa1
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.ge
n(
carr
y[3
]),.
pro
p(p
rop
[3])
);
a1cs
aa1
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.ge
n(
carr
y[4
]),.
pro
p(p
rop
[4])
);
a1cs
aa1
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
92
,.ge
n(
carr
y[5
]),.
pro
p(p
rop
[5])
);
a1cs
aa1
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.ge
n(
carr
y[6
]),.
pro
p(p
rop
[6])
);
assi
gnse
l[1
]=
carr
y[0
]|
(pro
p[0
]&
sel
[0])
;
assi
gnse
l[2
]=
carr
y[1
]|
(pro
p[1
]&
sel
[1])
;
assi
gnse
l[3
]=
carr
y[2
]|
(pro
p[2
]&
sel
[2])
;
assi
gnse
l[4
]=
carr
y[3
]|
(pro
p[3
]&
sel
[3])
;
assi
gnse
l[5
]=
carr
y[4
]|
(pro
p[4
]&
sel
[4])
;
assi
gnse
l[6
]=
carr
y[5
]|
(pro
p[5
]&
sel
[5])
;
assi
gnco
ut
=ca
rry
[6]
|(p
rop
[6]
&se
l[6
]);
endm
odul
e
C.1
.4C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
64bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a6
4b
its
//F
ile
Nam
e:
a1
csa
64
bit
s.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
64b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1
csa
64
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=6
4;
para
met
erm
=1
6;
93
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
]),.
pro
p(p
rop
[0])
);
a1cs
aa1
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
])
,.ge
n(
carr
y[1
]),.
pro
p(p
rop
[1])
);
a1cs
aa1
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.ge
n(
carr
y[2
]),.
pro
p(p
rop
[2])
);
a1cs
aa1
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.ge
n(
carr
y[3
]),.
pro
p(p
rop
[3])
);
a1cs
aa1
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.ge
n(
carr
y[4
]),.
pro
p(p
rop
[4])
);
a1cs
aa1
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.ge
n(
carr
y[5
]),.
pro
p(p
rop
[5])
);
a1cs
aa1
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
94
,.ge
n(
carr
y[6
]),.
pro
p(p
rop
[6])
);
a1cs
aa1
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.ge
n(
carr
y[7
]),.
pro
p(p
rop
[7])
);
a1cs
aa1
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.ge
n(
carr
y[8
]),.
pro
p(p
rop
[8])
);
a1cs
aa1
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
])
,.ge
n(
carr
y[9
]),.
pro
p(p
rop
[9])
);
a1cs
aa1
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.ge
n(
carr
y[1
0])
,.p
rop
(pro
p[1
0])
);
a1cs
aa1
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.ge
n(
carr
y[1
1])
,.p
rop
(pro
p[1
1])
);
a1cs
aa1
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.ge
n(
carr
y[1
2])
,.p
rop
(pro
p[1
2])
);
a1cs
aa1
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.ge
n(
carr
y[1
3])
,.p
rop
(pro
p[1
3])
);
a1cs
aa1
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.ge
n(
carr
y[1
4])
,.p
rop
(pro
p[1
4])
);
assi
gnse
l[1
]=
carr
y[0
]|
(pro
p[0
]&
sel
[0])
;
assi
gnse
l[2
]=
carr
y[1
]|
(pro
p[1
]&
sel
[1])
;
assi
gnse
l[3
]=
carr
y[2
]|
(pro
p[2
]&
sel
[2])
;
assi
gnse
l[4
]=
carr
y[3
]|
(pro
p[3
]&
sel
[3])
;
assi
gnse
l[5
]=
carr
y[4
]|
(pro
p[4
]&
sel
[4])
;
95
assi
gnse
l[6
]=
carr
y[5
]|
(pro
p[5
]&
sel
[5])
;
assi
gnse
l[7
]=
carr
y[6
]|
(pro
p[6
]&
sel
[6])
;
assi
gnse
l[8
]=
carr
y[7
]|
(pro
p[7
]&
sel
[7])
;
assi
gnse
l[9
]=
carr
y[8
]|
(pro
p[8
]&
sel
[8])
;
assi
gnse
l[1
0]
=ca
rry
[9]
|(p
rop
[9]
&se
l[9
]);
assi
gnse
l[1
1]
=ca
rry
[10
]|
(pro
p[1
0]
&se
l[1
0])
;
assi
gnse
l[1
2]
=ca
rry
[11
]|
(pro
p[1
1]
&se
l[1
1])
;
assi
gnse
l[1
3]
=ca
rry
[12
]|
(pro
p[1
2]
&se
l[1
2])
;
assi
gnse
l[1
4]
=ca
rry
[13
]|
(pro
p[1
3]
&se
l[1
3])
;
assi
gnco
ut
=ca
rry
[14
]|
(pro
p[1
4]
&se
l[1
4])
;
endm
odul
e
C.1
.5C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
128
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a1
28
bit
s
//F
ile
Nam
e:
a1
csa
12
8b
its
.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
128
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
a12
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=1
28
;
para
met
erm
=3
2;
96
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
]),.
pro
p(p
rop
[0])
);
a1cs
aa1
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
])
,.ge
n(
carr
y[1
]),.
pro
p(p
rop
[1])
);
a1cs
aa1
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.ge
n(
carr
y[2
]),.
pro
p(p
rop
[2])
);
a1cs
aa1
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.ge
n(
carr
y[3
]),.
pro
p(p
rop
[3])
);
a1cs
aa1
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.ge
n(
carr
y[4
]),.
pro
p(p
rop
[4])
);
a1cs
aa1
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.ge
n(
carr
y[5
]),.
pro
p(p
rop
[5])
);
a1cs
aa1
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.ge
n(
carr
y[6
]),.
pro
p(p
rop
[6])
);
97
a1cs
aa1
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.ge
n(
carr
y[7
]),.
pro
p(p
rop
[7])
);
a1cs
aa1
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.ge
n(
carr
y[8
]),.
pro
p(p
rop
[8])
);
a1cs
aa1
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
])
,.ge
n(
carr
y[9
]),.
pro
p(p
rop
[9])
);
a1cs
aa1
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.ge
n(
carr
y[1
0])
,.p
rop
(pro
p[1
0])
);
a1cs
aa1
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.ge
n(
carr
y[1
1])
,.p
rop
(pro
p[1
1])
);
a1cs
aa1
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.ge
n(
carr
y[1
2])
,.p
rop
(pro
p[1
2])
);
a1cs
aa1
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.ge
n(
carr
y[1
3])
,.p
rop
(pro
p[1
3])
);
a1cs
aa1
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.ge
n(
carr
y[1
4])
,.p
rop
(pro
p[1
4])
);
a1cs
aa1
csa_
16
(.se
l(se
l[1
5])
,.a
(a[6
7:6
4])
,.b
(b[6
7:6
4])
,.s
(s[6
7:6
4])
,.ge
n(
carr
y[1
5])
,.p
rop
(pro
p[1
5])
);
a1cs
aa1
csa_
17
(.se
l(se
l[1
6])
,.a
(a[7
1:6
8])
,.b
(b[7
1:6
8])
,.s
(s[7
1:6
8])
,.ge
n(
carr
y[1
6])
,.p
rop
(pro
p[1
6])
);
a1cs
aa1
csa_
18
(.se
l(se
l[1
7])
,.a
(a[7
5:7
2])
,.b
(b[7
5:7
2])
,.s
(s[7
5:7
2])
,.ge
n(
carr
y[1
7])
,.p
rop
(pro
p[1
7])
);
a1cs
aa1
csa_
19
(.se
l(se
l[1
8])
,.a
(a[7
9:7
6])
,.b
(b[7
9:7
6])
,.s
(s[7
9:7
6])
98
,.ge
n(
carr
y[1
8])
,.p
rop
(pro
p[1
8])
);
a1cs
aa1
csa_
20
(.se
l(se
l[1
9])
,.a
(a[8
3:8
0])
,.b
(b[8
3:8
0])
,.s
(s[8
3:8
0])
,.ge
n(
carr
y[1
9])
,.p
rop
(pro
p[1
9])
);
a1cs
aa1
csa_
21
(.se
l(se
l[2
0])
,.a
(a[8
7:8
4])
,.b
(b[8
7:8
4])
,.s
(s[8
7:8
4])
,.ge
n(
carr
y[2
0])
,.p
rop
(pro
p[2
0])
);
a1cs
aa1
csa_
22
(.se
l(se
l[2
1])
,.a
(a[9
1:8
8])
,.b
(b[9
1:8
8])
,.s
(s[9
1:8
8])
,.ge
n(
carr
y[2
1])
,.p
rop
(pro
p[2
1])
);
a1cs
aa1
csa_
23
(.se
l(se
l[2
2])
,.a
(a[9
5:9
2])
,.b
(b[9
5:9
2])
,.s
(s[9
5:9
2])
,.ge
n(
carr
y[2
2])
,.p
rop
(pro
p[2
2])
);
a1cs
aa1
csa_
24
(.se
l(se
l[2
3])
,.a
(a[9
9:9
6])
,.b
(b[9
9:9
6])
,.s
(s[9
9:9
6])
,.ge
n(
carr
y[2
3])
,.p
rop
(pro
p[2
3])
);
a1cs
aa1
csa_
25
(.se
l(se
l[2
4])
,.a
(a[1
03
:10
0])
,.b
(b[1
03
:10
0])
,.s
(s[1
03
:10
0])
,.ge
n(
carr
y[2
4])
,.p
rop
(pro
p[2
4])
);
a1cs
aa1
csa_
26
(.se
l(se
l[2
5])
,.a
(a[1
07
:10
4])
,.b
(b[1
07
:10
4])
,.s
(s[1
07
:10
4])
,.ge
n(
carr
y[2
5])
,.p
rop
(pro
p[2
5])
);
a1cs
aa1
csa_
27
(.se
l(se
l[2
6])
,.a
(a[1
11
:10
8])
,.b
(b[1
11
:10
8])
,.s
(s[1
11
:10
8])
,.ge
n(
carr
y[2
6])
,.p
rop
(pro
p[2
6])
);
a1cs
aa1
csa_
28
(.se
l(se
l[2
7])
,.a
(a[1
15
:11
2])
,.b
(b[1
15
:11
2])
,.s
(s[1
15
:11
2])
,.ge
n(
carr
y[2
7])
,.p
rop
(pro
p[2
7])
);
a1cs
aa1
csa_
29
(.se
l(se
l[2
8])
,.a
(a[1
19
:11
6])
,.b
(b[1
19
:11
6])
,.s
(s[1
19
:11
6])
,.ge
n(
carr
y[2
8])
,.p
rop
(pro
p[2
8])
);
a1cs
aa1
csa_
30
(.se
l(se
l[2
9])
,.a
(a[1
23
:12
0])
,.b
(b[1
23
:12
0])
,.s
(s[1
23
:12
0])
,.ge
n(
carr
y[2
9])
,.p
rop
(pro
p[2
9])
);
99
a1cs
aa1
csa_
31
(.se
l(se
l[3
0])
,.a
(a[1
27
:12
4])
,.b
(b[1
27
:12
4])
,.s
(s[1
27
:12
4])
,.ge
n(
carr
y[3
0])
,.p
rop
(pro
p[3
0])
);
assi
gnse
l[1
]=
carr
y[0
]|
(pro
p[0
]&
sel
[0])
;
assi
gnse
l[2
]=
carr
y[1
]|
(pro
p[1
]&
sel
[1])
;
assi
gnse
l[3
]=
carr
y[2
]|
(pro
p[2
]&
sel
[2])
;
assi
gnse
l[4
]=
carr
y[3
]|
(pro
p[3
]&
sel
[3])
;
assi
gnse
l[5
]=
carr
y[4
]|
(pro
p[4
]&
sel
[4])
;
assi
gnse
l[6
]=
carr
y[5
]|
(pro
p[5
]&
sel
[5])
;
assi
gnse
l[7
]=
carr
y[6
]|
(pro
p[6
]&
sel
[6])
;
assi
gnse
l[8
]=
carr
y[7
]|
(pro
p[7
]&
sel
[7])
;
assi
gnse
l[9
]=
carr
y[8
]|
(pro
p[8
]&
sel
[8])
;
assi
gnse
l[1
0]
=ca
rry
[9]
|(p
rop
[9]
&se
l[9
]);
assi
gnse
l[1
1]
=ca
rry
[10
]|
(pro
p[1
0]
&se
l[1
0])
;
assi
gnse
l[1
2]
=ca
rry
[11
]|
(pro
p[1
1]
&se
l[1
1])
;
assi
gnse
l[1
3]
=ca
rry
[12
]|
(pro
p[1
2]
&se
l[1
2])
;
assi
gnse
l[1
4]
=ca
rry
[13
]|
(pro
p[1
3]
&se
l[1
3])
;
assi
gnse
l[1
5]
=ca
rry
[14
]|
(pro
p[1
4]
&se
l[1
4])
;
assi
gnse
l[1
6]
=ca
rry
[15
]|
(pro
p[1
5]
&se
l[1
5])
;
assi
gnse
l[1
7]
=ca
rry
[16
]|
(pro
p[1
6]
&se
l[1
6])
;
assi
gnse
l[1
8]
=ca
rry
[17
]|
(pro
p[1
7]
&se
l[1
7])
;
assi
gnse
l[1
9]
=ca
rry
[18
]|
(pro
p[1
8]
&se
l[1
8])
;
assi
gnse
l[2
0]
=ca
rry
[19
]|
(pro
p[1
9]
&se
l[1
9])
;
100
assi
gnse
l[2
1]
=ca
rry
[20
]|
(pro
p[2
0]
&se
l[2
0])
;
assi
gnse
l[2
2]
=ca
rry
[21
]|
(pro
p[2
1]
&se
l[2
1])
;
assi
gnse
l[2
3]
=ca
rry
[22
]|
(pro
p[2
2]
&se
l[2
2])
;
assi
gnse
l[2
4]
=ca
rry
[23
]|
(pro
p[2
3]
&se
l[2
3])
;
assi
gnse
l[2
5]
=ca
rry
[24
]|
(pro
p[2
4]
&se
l[2
4])
;
assi
gnse
l[2
6]
=ca
rry
[25
]|
(pro
p[2
5]
&se
l[2
5])
;
assi
gnse
l[2
7]
=ca
rry
[26
]|
(pro
p[2
6]
&se
l[2
6])
;
assi
gnse
l[2
8]
=ca
rry
[27
]|
(pro
p[2
7]
&se
l[2
7])
;
assi
gnse
l[2
9]
=ca
rry
[28
]|
(pro
p[2
8]
&se
l[2
8])
;
assi
gnse
l[3
0]
=ca
rry
[29
]|
(pro
p[2
9]
&se
l[2
9])
;
assi
gnco
ut
=ca
rry
[30
]|
(pro
p[3
0]
&se
l[3
0])
;
endm
odul
e
C.1
.6C
ódig
oFo
nte
doA
dd-O
neC
arry
-Sel
ectA
dder
256
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
a2
56
bit
s
//F
ile
Nam
e:
a1
csa
25
6b
its
.v
//F
un
ctio
n:
Add
One
Ca
rry
Se
lec
tA
dder
for
256
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
a25
6b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=2
56
;
para
met
erm
=6
4;
101
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
carr
y,p
rop
,se
l;
cra
4b
its
a1cs
a_0
(.ci
n(
cin
),.
a(a
[3:0
]),.
b(b
[3:0
]),.
s(s
[3:0
]),.
cou
t(se
l[0
]));
a1cs
aa1
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.ge
n(
carr
y[0
]),.
pro
p(p
rop
[0])
);
a1cs
aa1
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
])
,.ge
n(
carr
y[1
]),.
pro
p(p
rop
[1])
);
a1cs
aa1
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.ge
n(
carr
y[2
]),.
pro
p(p
rop
[2])
);
a1cs
aa1
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.ge
n(
carr
y[3
]),.
pro
p(p
rop
[3])
);
a1cs
aa1
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.ge
n(
carr
y[4
]),.
pro
p(p
rop
[4])
);
a1cs
aa1
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.ge
n(
carr
y[5
]),.
pro
p(p
rop
[5])
);
a1cs
aa1
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
102
,.ge
n(
carr
y[6
]),.
pro
p(p
rop
[6])
);
a1cs
aa1
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.ge
n(
carr
y[7
]),.
pro
p(p
rop
[7])
);
a1cs
aa1
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.ge
n(
carr
y[8
]),.
pro
p(p
rop
[8])
);
a1cs
aa1
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
])
,.ge
n(
carr
y[9
]),.
pro
p(p
rop
[9])
);
a1cs
aa1
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.ge
n(
carr
y[1
0])
,.p
rop
(pro
p[1
0])
);
a1cs
aa1
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.ge
n(
carr
y[1
1])
,.p
rop
(pro
p[1
1])
);
a1cs
aa1
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.ge
n(
carr
y[1
2])
,.p
rop
(pro
p[1
2])
);
a1cs
aa1
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.ge
n(
carr
y[1
3])
,.p
rop
(pro
p[1
3])
);
a1cs
aa1
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.ge
n(
carr
y[1
4])
,.p
rop
(pro
p[1
4])
);
a1cs
aa1
csa_
16
(.se
l(se
l[1
5])
,.a
(a[6
7:6
4])
,.b
(b[6
7:6
4])
,.s
(s[6
7:6
4])
,.ge
n(
carr
y[1
5])
,.p
rop
(pro
p[1
5])
);
a1cs
aa1
csa_
17
(.se
l(se
l[1
6])
,.a
(a[7
1:6
8])
,.b
(b[7
1:6
8])
,.s
(s[7
1:6
8])
,.ge
n(
carr
y[1
6])
,.p
rop
(pro
p[1
6])
);
a1cs
aa1
csa_
18
(.se
l(se
l[1
7])
,.a
(a[7
5:7
2])
,.b
(b[7
5:7
2])
,.s
(s[7
5:7
2])
,.ge
n(
carr
y[1
7])
,.p
rop
(pro
p[1
7])
);
103
a1cs
aa1
csa_
19
(.se
l(se
l[1
8])
,.a
(a[7
9:7
6])
,.b
(b[7
9:7
6])
,.s
(s[7
9:7
6])
,.ge
n(
carr
y[1
8])
,.p
rop
(pro
p[1
8])
);
a1cs
aa1
csa_
20
(.se
l(se
l[1
9])
,.a
(a[8
3:8
0])
,.b
(b[8
3:8
0])
,.s
(s[8
3:8
0])
,.ge
n(
carr
y[1
9])
,.p
rop
(pro
p[1
9])
);
a1cs
aa1
csa_
21
(.se
l(se
l[2
0])
,.a
(a[8
7:8
4])
,.b
(b[8
7:8
4])
,.s
(s[8
7:8
4])
,.ge
n(
carr
y[2
0])
,.p
rop
(pro
p[2
0])
);
a1cs
aa1
csa_
22
(.se
l(se
l[2
1])
,.a
(a[9
1:8
8])
,.b
(b[9
1:8
8])
,.s
(s[9
1:8
8])
,.ge
n(
carr
y[2
1])
,.p
rop
(pro
p[2
1])
);
a1cs
aa1
csa_
23
(.se
l(se
l[2
2])
,.a
(a[9
5:9
2])
,.b
(b[9
5:9
2])
,.s
(s[9
5:9
2])
,.ge
n(
carr
y[2
2])
,.p
rop
(pro
p[2
2])
);
a1cs
aa1
csa_
24
(.se
l(se
l[2
3])
,.a
(a[9
9:9
6])
,.b
(b[9
9:9
6])
,.s
(s[9
9:9
6])
,.ge
n(
carr
y[2
3])
,.p
rop
(pro
p[2
3])
);
a1cs
aa1
csa_
25
(.se
l(se
l[2
4])
,.a
(a[1
03
:10
0])
,.b
(b[1
03
:10
0])
,.s
(s[1
03
:10
0])
,.ge
n(
carr
y[2
4])
,.p
rop
(pro
p[2
4])
);
a1cs
aa1
csa_
26
(.se
l(se
l[2
5])
,.a
(a[1
07
:10
4])
,.b
(b[1
07
:10
4])
,.s
(s[1
07
:10
4])
,.ge
n(
carr
y[2
5])
,.p
rop
(pro
p[2
5])
);
a1cs
aa1
csa_
27
(.se
l(se
l[2
6])
,.a
(a[1
11
:10
8])
,.b
(b[1
11
:10
8])
,.s
(s[1
11
:10
8])
,.ge
n(
carr
y[2
6])
,.p
rop
(pro
p[2
6])
);
a1cs
aa1
csa_
28
(.se
l(se
l[2
7])
,.a
(a[1
15
:11
2])
,.b
(b[1
15
:11
2])
,.s
(s[1
15
:11
2])
,.ge
n(
carr
y[2
7])
,.p
rop
(pro
p[2
7])
);
a1cs
aa1
csa_
29
(.se
l(se
l[2
8])
,.a
(a[1
19
:11
6])
,.b
(b[1
19
:11
6])
,.s
(s[1
19
:11
6])
,.ge
n(
carr
y[2
8])
,.p
rop
(pro
p[2
8])
);
a1cs
aa1
csa_
30
(.se
l(se
l[2
9])
,.a
(a[1
23
:12
0])
,.b
(b[1
23
:12
0])
,.s
(s[1
23
:12
0])
104
,.ge
n(
carr
y[2
9])
,.p
rop
(pro
p[2
9])
);
a1cs
aa1
csa_
31
(.se
l(se
l[3
0])
,.a
(a[1
27
:12
4])
,.b
(b[1
27
:12
4])
,.s
(s[1
27
:12
4])
,.ge
n(
carr
y[3
0])
,.p
rop
(pro
p[3
0])
);
a1cs
aa1
csa_
32
(.se
l(se
l[3
1])
,.a
(a[1
31
:12
8])
,.b
(b[1
31
:12
8])
,.s
(s[1
31
:12
8])
,.ge
n(
carr
y[3
1])
,.p
rop
(pro
p[3
1])
);
a1cs
aa1
csa_
33
(.se
l(se
l[3
2])
,.a
(a[1
35
:13
2])
,.b
(b[1
35
:13
2])
,.s
(s[1
35
:13
2])
,.ge
n(
carr
y[3
2])
,.p
rop
(pro
p[3
2])
);
a1cs
aa1
csa_
34
(.se
l(se
l[3
3])
,.a
(a[1
39
:13
6])
,.b
(b[1
39
:13
6])
,.s
(s[1
39
:13
6])
,.ge
n(
carr
y[3
3])
,.p
rop
(pro
p[3
3])
);
a1cs
aa1
csa_
35
(.se
l(se
l[3
4])
,.a
(a[1
43
:14
0])
,.b
(b[1
43
:14
0])
,.s
(s[1
43
:14
0])
,.ge
n(
carr
y[3
4])
,.p
rop
(pro
p[3
4])
);
a1cs
aa1
csa_
36
(.se
l(se
l[3
5])
,.a
(a[1
47
:14
4])
,.b
(b[1
47
:14
4])
,.s
(s[1
47
:14
4])
,.ge
n(
carr
y[3
5])
,.p
rop
(pro
p[3
5])
);
a1cs
aa1
csa_
37
(.se
l(se
l[3
6])
,.a
(a[1
51
:14
8])
,.b
(b[1
51
:14
8])
,.s
(s[1
51
:14
8])
,.ge
n(
carr
y[3
6])
,.p
rop
(pro
p[3
6])
);
a1cs
aa1
csa_
38
(.se
l(se
l[3
7])
,.a
(a[1
55
:15
2])
,.b
(b[1
55
:15
2])
,.s
(s[1
55
:15
2])
,.ge
n(
carr
y[3
7])
,.p
rop
(pro
p[3
7])
);
a1cs
aa1
csa_
39
(.se
l(se
l[3
8])
,.a
(a[1
59
:15
6])
,.b
(b[1
59
:15
6])
,.s
(s[1
59
:15
6])
,.ge
n(
carr
y[3
8])
,.p
rop
(pro
p[3
8])
);
a1cs
aa1
csa_
40
(.se
l(se
l[3
9])
,.a
(a[1
63
:16
0])
,.b
(b[1
63
:16
0])
,.s
(s[1
63
:16
0])
,.ge
n(
carr
y[3
9])
,.p
rop
(pro
p[3
9])
);
a1cs
aa1
csa_
41
(.se
l(se
l[4
0])
,.a
(a[1
67
:16
4])
,.b
(b[1
67
:16
4])
,.s
(s[1
67
:16
4])
,.ge
n(
carr
y[4
0])
,.p
rop
(pro
p[4
0])
);
105
a1cs
aa1
csa_
42
(.se
l(se
l[4
1])
,.a
(a[1
71
:16
8])
,.b
(b[1
71
:16
8])
,.s
(s[1
71
:16
8])
,.ge
n(
carr
y[4
1])
,.p
rop
(pro
p[4
1])
);
a1cs
aa1
csa_
43
(.se
l(se
l[4
2])
,.a
(a[1
75
:17
2])
,.b
(b[1
75
:17
2])
,.s
(s[1
75
:17
2])
,.ge
n(
carr
y[4
2])
,.p
rop
(pro
p[4
2])
);
a1cs
aa1
csa_
44
(.se
l(se
l[4
3])
,.a
(a[1
79
:17
6])
,.b
(b[1
79
:17
6])
,.s
(s[1
79
:17
6])
,.ge
n(
carr
y[4
3])
,.p
rop
(pro
p[4
3])
);
a1cs
aa1
csa_
45
(.se
l(se
l[4
4])
,.a
(a[1
83
:18
0])
,.b
(b[1
83
:18
0])
,.s
(s[1
83
:18
0])
,.ge
n(
carr
y[4
4])
,.p
rop
(pro
p[4
4])
);
a1cs
aa1
csa_
46
(.se
l(se
l[4
5])
,.a
(a[1
87
:18
4])
,.b
(b[1
87
:18
4])
,.s
(s[1
87
:18
4])
,.ge
n(
carr
y[4
5])
,.p
rop
(pro
p[4
5])
);
a1cs
aa1
csa_
47
(.se
l(se
l[4
6])
,.a
(a[1
91
:18
8])
,.b
(b[1
91
:18
8])
,.s
(s[1
91
:18
8])
,.ge
n(
carr
y[4
6])
,.p
rop
(pro
p[4
6])
);
a1cs
aa1
csa_
48
(.se
l(se
l[4
7])
,.a
(a[1
95
:19
2])
,.b
(b[1
95
:19
2])
,.s
(s[1
95
:19
2])
,.ge
n(
carr
y[4
7])
,.p
rop
(pro
p[4
7])
);
a1cs
aa1
csa_
49
(.se
l(se
l[4
8])
,.a
(a[1
99
:19
6])
,.b
(b[1
99
:19
6])
,.s
(s[1
99
:19
6])
,.ge
n(
carr
y[4
8])
,.p
rop
(pro
p[4
8])
);
a1cs
aa1
csa_
50
(.se
l(se
l[4
9])
,.a
(a[2
03
:20
0])
,.b
(b[2
03
:20
0])
,.s
(s[2
03
:20
0])
,.ge
n(
carr
y[4
9])
,.p
rop
(pro
p[4
9])
);
a1cs
aa1
csa_
51
(.se
l(se
l[5
0])
,.a
(a[2
07
:20
4])
,.b
(b[2
07
:20
4])
,.s
(s[2
07
:20
4])
,.ge
n(
carr
y[5
0])
,.p
rop
(pro
p[5
0])
);
a1cs
aa1
csa_
52
(.se
l(se
l[5
1])
,.a
(a[2
11
:20
8])
,.b
(b[2
11
:20
8])
,.s
(s[2
11
:20
8])
,.ge
n(
carr
y[5
1])
,.p
rop
(pro
p[5
1])
);
a1cs
aa1
csa_
53
(.se
l(se
l[5
2])
,.a
(a[2
15
:21
2])
,.b
(b[2
15
:21
2])
,.s
(s[2
15
:21
2])
106
,.ge
n(
carr
y[5
2])
,.p
rop
(pro
p[5
2])
);
a1cs
aa1
csa_
54
(.se
l(se
l[5
3])
,.a
(a[2
19
:21
6])
,.b
(b[2
19
:21
6])
,.s
(s[2
19
:21
6])
,.ge
n(
carr
y[5
3])
,.p
rop
(pro
p[5
3])
);
a1cs
aa1
csa_
55
(.se
l(se
l[5
4])
,.a
(a[2
23
:22
0])
,.b
(b[2
23
:22
0])
,.s
(s[2
23
:22
0])
,.ge
n(
carr
y[5
4])
,.p
rop
(pro
p[5
4])
);
a1cs
aa1
csa_
56
(.se
l(se
l[5
5])
,.a
(a[2
27
:22
4])
,.b
(b[2
27
:22
4])
,.s
(s[2
27
:22
4])
,.ge
n(
carr
y[5
5])
,.p
rop
(pro
p[5
5])
);
a1cs
aa1
csa_
57
(.se
l(se
l[5
6])
,.a
(a[2
31
:22
8])
,.b
(b[2
31
:22
8])
,.s
(s[2
31
:22
8])
,.ge
n(
carr
y[5
6])
,.p
rop
(pro
p[5
6])
);
a1cs
aa1
csa_
58
(.se
l(se
l[5
7])
,.a
(a[2
35
:23
2])
,.b
(b[2
35
:23
2])
,.s
(s[2
35
:23
2])
,.ge
n(
carr
y[5
7])
,.p
rop
(pro
p[5
7])
);
a1cs
aa1
csa_
59
(.se
l(se
l[5
8])
,.a
(a[2
39
:23
6])
,.b
(b[2
39
:23
6])
,.s
(s[2
39
:23
6])
,.ge
n(
carr
y[5
8])
,.p
rop
(pro
p[5
8])
);
a1cs
aa1
csa_
60
(.se
l(se
l[5
9])
,.a
(a[2
43
:24
0])
,.b
(b[2
43
:24
0])
,.s
(s[2
43
:24
0])
,.ge
n(
carr
y[5
9])
,.p
rop
(pro
p[5
9])
);
a1cs
aa1
csa_
61
(.se
l(se
l[6
0])
,.a
(a[2
47
:24
4])
,.b
(b[2
47
:24
4])
,.s
(s[2
47
:24
4])
,.ge
n(
carr
y[6
0])
,.p
rop
(pro
p[6
0])
);
a1cs
aa1
csa_
62
(.se
l(se
l[6
1])
,.a
(a[2
51
:24
8])
,.b
(b[2
51
:24
8])
,.s
(s[2
51
:24
8])
,.ge
n(
carr
y[6
1])
,.p
rop
(pro
p[6
1])
);
a1cs
aa1
csa_
63
(.se
l(se
l[6
2])
,.a
(a[2
55
:25
2])
,.b
(b[2
55
:25
2])
,.s
(s[2
55
:25
2])
,.ge
n(
carr
y[6
2])
,.p
rop
(pro
p[6
2])
);
assi
gnse
l[1
]=
carr
y[0
]|
(pro
p[0
]&
sel
[0])
;
107
assi
gnse
l[2
]=
carr
y[1
]|
(pro
p[1
]&
sel
[1])
;
assi
gnse
l[3
]=
carr
y[2
]|
(pro
p[2
]&
sel
[2])
;
assi
gnse
l[4
]=
carr
y[3
]|
(pro
p[3
]&
sel
[3])
;
assi
gnse
l[5
]=
carr
y[4
]|
(pro
p[4
]&
sel
[4])
;
assi
gnse
l[6
]=
carr
y[5
]|
(pro
p[5
]&
sel
[5])
;
assi
gnse
l[7
]=
carr
y[6
]|
(pro
p[6
]&
sel
[6])
;
assi
gnse
l[8
]=
carr
y[7
]|
(pro
p[7
]&
sel
[7])
;
assi
gnse
l[9
]=
carr
y[8
]|
(pro
p[8
]&
sel
[8])
;
assi
gnse
l[1
0]
=ca
rry
[9]
|(p
rop
[9]
&se
l[9
]);
assi
gnse
l[1
1]
=ca
rry
[10
]|
(pro
p[1
0]
&se
l[1
0])
;
assi
gnse
l[1
2]
=ca
rry
[11
]|
(pro
p[1
1]
&se
l[1
1])
;
assi
gnse
l[1
3]
=ca
rry
[12
]|
(pro
p[1
2]
&se
l[1
2])
;
assi
gnse
l[1
4]
=ca
rry
[13
]|
(pro
p[1
3]
&se
l[1
3])
;
assi
gnse
l[1
5]
=ca
rry
[14
]|
(pro
p[1
4]
&se
l[1
4])
;
assi
gnse
l[1
6]
=ca
rry
[15
]|
(pro
p[1
5]
&se
l[1
5])
;
assi
gnse
l[1
7]
=ca
rry
[16
]|
(pro
p[1
6]
&se
l[1
6])
;
assi
gnse
l[1
8]
=ca
rry
[17
]|
(pro
p[1
7]
&se
l[1
7])
;
assi
gnse
l[1
9]
=ca
rry
[18
]|
(pro
p[1
8]
&se
l[1
8])
;
assi
gnse
l[2
0]
=ca
rry
[19
]|
(pro
p[1
9]
&se
l[1
9])
;
assi
gnse
l[2
1]
=ca
rry
[20
]|
(pro
p[2
0]
&se
l[2
0])
;
assi
gnse
l[2
2]
=ca
rry
[21
]|
(pro
p[2
1]
&se
l[2
1])
;
assi
gnse
l[2
3]
=ca
rry
[22
]|
(pro
p[2
2]
&se
l[2
2])
;
assi
gnse
l[2
4]
=ca
rry
[23
]|
(pro
p[2
3]
&se
l[2
3])
;
108
assi
gnse
l[2
5]
=ca
rry
[24
]|
(pro
p[2
4]
&se
l[2
4])
;
assi
gnse
l[2
6]
=ca
rry
[25
]|
(pro
p[2
5]
&se
l[2
5])
;
assi
gnse
l[2
7]
=ca
rry
[26
]|
(pro
p[2
6]
&se
l[2
6])
;
assi
gnse
l[2
8]
=ca
rry
[27
]|
(pro
p[2
7]
&se
l[2
7])
;
assi
gnse
l[2
9]
=ca
rry
[28
]|
(pro
p[2
8]
&se
l[2
8])
;
assi
gnse
l[3
0]
=ca
rry
[29
]|
(pro
p[2
9]
&se
l[2
9])
;
assi
gnse
l[3
1]
=ca
rry
[30
]|
(pro
p[3
0]
&se
l[3
0])
;
assi
gnse
l[3
2]
=ca
rry
[31
]|
(pro
p[3
1]
&se
l[3
1])
;
assi
gnse
l[3
3]
=ca
rry
[32
]|
(pro
p[3
2]
&se
l[3
2])
;
assi
gnse
l[3
4]
=ca
rry
[33
]|
(pro
p[3
3]
&se
l[3
3])
;
assi
gnse
l[3
5]
=ca
rry
[34
]|
(pro
p[3
4]
&se
l[3
4])
;
assi
gnse
l[3
6]
=ca
rry
[35
]|
(pro
p[3
5]
&se
l[3
5])
;
assi
gnse
l[3
7]
=ca
rry
[36
]|
(pro
p[3
6]
&se
l[3
6])
;
assi
gnse
l[3
8]
=ca
rry
[37
]|
(pro
p[3
7]
&se
l[3
7])
;
assi
gnse
l[3
9]
=ca
rry
[38
]|
(pro
p[3
8]
&se
l[3
8])
;
assi
gnse
l[4
0]
=ca
rry
[39
]|
(pro
p[3
9]
&se
l[3
9])
;
assi
gnse
l[4
1]
=ca
rry
[40
]|
(pro
p[4
0]
&se
l[4
0])
;
assi
gnse
l[4
2]
=ca
rry
[41
]|
(pro
p[4
1]
&se
l[4
1])
;
assi
gnse
l[4
3]
=ca
rry
[42
]|
(pro
p[4
2]
&se
l[4
2])
;
assi
gnse
l[4
4]
=ca
rry
[43
]|
(pro
p[4
3]
&se
l[4
3])
;
assi
gnse
l[4
5]
=ca
rry
[44
]|
(pro
p[4
4]
&se
l[4
4])
;
assi
gnse
l[4
6]
=ca
rry
[45
]|
(pro
p[4
5]
&se
l[4
5])
;
assi
gnse
l[4
7]
=ca
rry
[46
]|
(pro
p[4
6]
&se
l[4
6])
;
109
assi
gnse
l[4
8]
=ca
rry
[47
]|
(pro
p[4
7]
&se
l[4
7])
;
assi
gnse
l[4
9]
=ca
rry
[48
]|
(pro
p[4
8]
&se
l[4
8])
;
assi
gnse
l[5
0]
=ca
rry
[49
]|
(pro
p[4
9]
&se
l[4
9])
;
assi
gnse
l[5
1]
=ca
rry
[50
]|
(pro
p[5
0]
&se
l[5
0])
;
assi
gnse
l[5
2]
=ca
rry
[51
]|
(pro
p[5
1]
&se
l[5
1])
;
assi
gnse
l[5
3]
=ca
rry
[52
]|
(pro
p[5
2]
&se
l[5
2])
;
assi
gnse
l[5
4]
=ca
rry
[53
]|
(pro
p[5
3]
&se
l[5
3])
;
assi
gnse
l[5
5]
=ca
rry
[54
]|
(pro
p[5
4]
&se
l[5
4])
;
assi
gnse
l[5
6]
=ca
rry
[55
]|
(pro
p[5
5]
&se
l[5
5])
;
assi
gnse
l[5
7]
=ca
rry
[56
]|
(pro
p[5
6]
&se
l[5
6])
;
assi
gnse
l[5
8]
=ca
rry
[57
]|
(pro
p[5
7]
&se
l[5
7])
;
assi
gnse
l[5
9]
=ca
rry
[58
]|
(pro
p[5
8]
&se
l[5
8])
;
assi
gnse
l[6
0]
=ca
rry
[59
]|
(pro
p[5
9]
&se
l[5
9])
;
assi
gnse
l[6
1]
=ca
rry
[60
]|
(pro
p[6
0]
&se
l[6
0])
;
assi
gnse
l[6
2]
=ca
rry
[61
]|
(pro
p[6
1]
&se
l[6
1])
;
assi
gnco
ut
=ca
rry
[62
]|
(pro
p[6
2]
&se
l[6
2])
;
endm
odul
e
C.2
Cód
igo
Font
edo
Hie
rarc
hica
lAdd
-One
Car
ry-S
elec
tAdd
er
C.2
.1C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
8bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
0
110
//F
ile
Nam
e:
rb0
.v
//F
un
ctio
n:
Add
One
for
Fir
stB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb0
(se
l,
s,
rs);
para
met
ern
=1
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=se
l^
s[0
];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
1
//F
ile
Nam
e:
rb1
.v
//F
un
ctio
n:
Add
One
for
Sec
on
dB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb1
(se
l,
s,
rs);
para
met
ern
=2
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0])
^s
[1];
111
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
2
//F
ile
Nam
e:
rb2
.v
//F
un
ctio
n:
Add
One
for
Th
ird
Bit
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb2
(se
l,
s,
rs);
para
met
ern
=3
;
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0]
&s
[1])
^s
[2];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:rb
3
//F
ile
Nam
e:
rb3
.v
//F
un
ctio
n:
Add
One
for
Fo
urt
hB
it
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
rb3
(se
l,
s,
rs);
para
met
ern
=4
;
112
inp
ut
[n−
1:0]
s;
inp
ut
sel
;
outp
ut
rs;
assi
gnrs
=(
sel
&s
[0]
&s
[1]
&s
[2])
^s
[3];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
lac
in0
//F
ile
Nam
e:
cla
cin
0.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
4b
its
whe
nC
INis
0
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
cin
0(a
,b,s
,gen
,pro
p);
para
met
ern
=4
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
wir
e[n−
2:0]
carr
y;
wir
e[n−
1:0]
g,p
;
113
gen
_u
nit
gu0
(.a
(a[0
]),.
b(b
[0])
,.g
(g[0
]));
gen
_u
nit
gu1
(.a
(a[1
]),.
b(b
[1])
,.g
(g[1
]));
gen
_u
nit
gu2
(.a
(a[2
]),.
b(b
[2])
,.g
(g[2
]));
gen
_u
nit
gu3
(.a
(a[3
]),.
b(b
[3])
,.g
(g[3
]));
pro
p_
un
itpu
0(.
a(a
[0])
,.b
(b[0
]),.
p(p
[0])
);
pro
p_
un
itpu
1(.
a(a
[1])
,.b
(b[1
]),.
p(p
[1])
);
pro
p_
un
itpu
2(.
a(a
[2])
,.b
(b[2
]),.
p(p
[2])
);
pro
p_
un
itpu
3(.
a(a
[3])
,.b
(b[3
]),.
p(p
[3])
);
assi
gnca
rry
[0]
=g
[0];
c2ci
n0
carr
y2
(.g
(g[1
:0])
,.p
(p[1
:1])
,.ca
rry
(ca
rry
[1])
);
c3ci
n0
carr
y3
(.g
(g[2
:0])
,.p
(p[2
:1])
,.ca
rry
(ca
rry
[2])
);
gen
_si
gn
alge
n_su
m(.
g(g
[n−
1:0
]),
.p(p
[n−
1:1
]),
.car
ry(g
en))
;
pro
p_
sig
nal
prop
_sum
(.p
(p[n−
1:0
]),.
pro
p(p
rop
));
assi
gns
[0]
=p
[0];
sum
sum
1(.
a(
carr
y[0
]),.
b(p
[1])
,.s
(s[1
]));
sum
sum
2(.
a(
carr
y[1
]),.
b(p
[2])
,.s
(s[2
]));
sum
sum
3(.
a(
carr
y[2
]),.
b(p
[3])
,.s
(s[3
]));
endm
odul
e
114
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
//F
ile
Nam
e:
a1
csa
h.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah(
sel
,a,b
,s,g
en,p
rop
);
para
met
ern
=4
;
inp
ut
sel
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
wir
e[n−
1:0]
s0,r
s,c
arry
;
cla
cin
0cl
a_b
ase
(.a
(a[n−
1:0
]),.
b(b
[n−
1:0
]),.
s(s
0[n−
1:0
]),.
gen
(gen
),.
pro
p(p
rop
));
rb0
r0(.
sel(
sel
),.
s(s
0[0
]),.
rs(s
[0])
);
rb1
r1(.
sel(
sel
),.
s(s
0[1
:0])
,.rs
(s[1
]));
rb2
r2(.
sel(
sel
),.
s(s
0[2
:0])
,.rs
(s[2
]));
115
rb3
r3(.
sel(
sel
),.
s(s
0[3
:0])
,.rs
(s[3
]));
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
8b
its
//F
ile
Nam
e:
a1
csa
h8
bit
s.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
8b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1
csa
h8
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
para
met
ern
=8
;
para
met
erm
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
epr
op0
,gen
0,p
rop1
,gen
1,s
el
;
a1cs
aha1
csah
_0
(.se
l(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
116
,.ge
n(g
en0
),.
pro
p(p
rop
0))
;
a1cs
aha1
csah
_1
(.se
l(se
l)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
C.2
.2C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
16bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
16
bit
s
//F
ile
Nam
e:
a1
csa
h1
6b
its
.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah1
6b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=1
6;
para
met
erm
=8
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
117
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
epr
op0
,gen
0,p
rop1
,gen
1,c
ou
t0,c
ou
t1,s
el
;
a1
csa
h8
bit
sa1
csah
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
a1
csa
h8
bit
sa1
csah
_1
(.ci
n(
sel
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
C.2
.3C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
32bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
32
bit
s
//F
ile
Nam
e:
a1
csa
h3
2b
its
.v
118
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah3
2b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=3
2;
para
met
erm
=1
6;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
epr
op0
,gen
0,p
rop1
,gen
1,c
ou
t0,c
ou
t1,s
el
;
a1cs
ah1
6b
its
a1cs
ah_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
a1cs
ah1
6b
its
a1cs
ah_
1(.
cin
(se
l)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
119
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
C.2
.4C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
64bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
64
bit
s
//F
ile
Nam
e:
a1
csa
h6
4b
its
.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
64b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah6
4b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=6
4;
para
met
erm
=3
2;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
120
wir
epr
op0
,gen
0,p
rop1
,gen
1,c
ou
t0,c
ou
t1,s
el
;
a1cs
ah3
2b
its
a1cs
ah_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
a1cs
ah3
2b
its
a1cs
ah_
1(.
cin
(se
l)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
C.2
.5C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
128
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
12
8b
its
//F
ile
Nam
e:
a1
csa
h1
28
bit
s.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
128
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah1
28
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
121
para
met
ern
=1
28
;
para
met
erm
=6
4;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
epr
op0
,gen
0,p
rop1
,gen
1,c
ou
t0,c
ou
t1,s
el
;
a1cs
ah6
4b
its
a1cs
ah_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
a1cs
ah6
4b
its
a1cs
ah_
1(.
cin
(se
l)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
122
C.2
.6C
ódig
oFo
nte
doH
iera
rchi
calA
dd-O
neC
arry
-Sel
ectA
dder
256
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:a
1cs
ah
25
6b
its
//F
ile
Nam
e:
a1
csa
h2
56
bit
s.v
//F
un
ctio
n:
Hie
rarc
hic
al
Add
One
Ca
rry
Se
lec
tA
dder
for
256
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
a1cs
ah2
56
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
para
met
ern
=2
56
;
para
met
erm
=1
28
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
epr
op0
,gen
0,p
rop1
,gen
1,c
ou
t0,c
ou
t1,s
el
;
a1cs
ah1
28
bit
sa1
csah
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
123
a1cs
ah1
28
bit
sa1
csah
_1
(.ci
n(
sel
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnse
l=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
assi
gnp
rop
=p
rop
1&
pro
p0
;
endm
odul
e
C.3
Cód
igo
Font
edo
Car
ry-R
ippl
eA
dder
C.3
.1C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er8
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:fu
ll_
ad
de
r
//F
ile
Nam
e:
full
_a
dd
er
.v
//F
un
ctio
n:
Fu
llA
dder
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
full
_a
dd
er
(cin
,a,b
,s,c
ou
t);
inp
ut
cin
,a,b
;
outp
ut
s,c
ou
t;
assi
gns
=(a
^b
)^
cin
;
124
assi
gnco
ut
=(a
&b
)|
(a&
cin
)|
(b&
cin
);
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra4
bit
s
//F
ile
Nam
e:
cra
4b
its
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
4b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[n−
2:0]
c;
full
_a
dd
er
cra4
_0
(.ci
n(
cin
),.
a(a
[0])
,.b
(b[0
]),.
s(s
[0])
,.co
ut(
c[0
]));
full
_a
dd
er
cra4
_1
(.ci
n(c
[0])
,.a
(a[1
]),.
b(b
[1])
,.s
(s[1
]),.
cou
t(c
[1])
);
full
_a
dd
er
cra4
_2
(.ci
n(c
[1])
,.a
(a[2
]),.
b(b
[2])
,.s
(s[2
]),.
cou
t(c
[2])
);
full
_a
dd
er
cra4
_3
(.ci
n(c
[2])
,.a
(a[3
]),.
b(b
[3])
,.s
(s[3
]),.
cou
t(co
ut
));
125
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra8
bit
s
//F
ile
Nam
e:
cra
8b
its
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
8b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=8
;
para
met
erm
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
4b
its
cra8
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
4b
its
cra8
_1
(.ci
n(c
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
126
C.3
.2C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er16
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra1
6b
its
//F
ile
Nam
e:
cra
16
bit
s.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
16
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=1
6;
para
met
erm
=8
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
8b
its
cra1
6_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
8b
its
cra1
6_
1(.
cin
(c)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
127
C.3
.3C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er32
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra3
2b
its
//F
ile
Nam
e:
cra
32
bit
s.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
32b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
32
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=3
2;
para
met
erm
=1
6;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
16
bit
scr
a32
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
16
bit
scr
a32
_1
(.ci
n(c
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
128
C.3
.4C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er64
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra6
4b
its
//F
ile
Nam
e:
cra
64
bit
s.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
64b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
64
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=6
4;
para
met
erm
=3
2;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
32
bit
scr
a64
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
32
bit
scr
a64
_1
(.ci
n(c
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
129
C.3
.5C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er12
8bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra1
28
bit
s
//F
ile
Nam
e:
cra
12
8b
its
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
128
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
12
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=1
28
;
para
met
erm
=6
4;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
64
bit
scr
a12
8_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
64
bit
scr
a12
8_
1(.
cin
(c)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
130
C.3
.6C
ódig
oFo
nte
doC
arry
-Rip
ple
Add
er25
6bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra2
56
bit
s
//F
ile
Nam
e:
cra
25
6b
its
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
256
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
25
6b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=2
56
;
para
met
erm
=1
28
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
ec
;
cra
12
8b
its
cra2
56
_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
]),.
cou
t(c
));
cra
12
8b
its
cra2
56
_1
(.ci
n(c
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
]),.
cou
t(co
ut
));
endm
odul
e
131
C.4
Cód
igo
Font
edo
Car
ry-L
ooka
head
Add
er
C.4
.1C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
8bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:g
en_
un
it
//F
ile
Nam
e:
gen
_u
nit
.v
//F
un
ctio
n:
Det
ecti
ng
Ca
rry
Gen
era
tefr
om
Op
era
tor
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
gen
_u
nit
(a,b
,g);
inp
ut
a;
inp
ut
b;
outp
ut
g;
assi
gng
=a
&b
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:p
rop
_u
nit
//F
ile
Nam
e:
pro
p_
un
it.v
//F
un
ctio
n:
Det
ecti
ng
Ca
rry
Pro
pa
ga
tefr
om
Op
era
tors
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
132
mod
ule
pro
p_
un
it(a
,b,p
);
inp
ut
a;
inp
ut
b;
outp
ut
p;
assi
gnp
=a
^b
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c1
//F
ile
Nam
e:
c1.v
//F
un
ctio
n:
Ca
rry
Gen
era
tefo
rF
irst
Bit
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
c1(c
in,g
,p,c
arry
);
para
met
ern
=1
;
inp
ut
cin
;
inp
ut
[n−
1:0]
g;
inp
ut
[n−
1:0]
p;
outp
ut
carr
y;
assi
gnca
rry
=g
[0]
|(p
[0]
&ci
n);
endm
odul
e
133
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c2
//F
ile
Nam
e:
c2.v
//F
un
ctio
n:
Ca
rry
Gen
era
tefo
rS
eco
nd
Bit
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
c2(c
in,g
,p,c
arry
);
para
met
ern
=2
;
inp
ut
cin
;
inp
ut
[n−
1:0]
g;
inp
ut
[n−
1:0]
p;
outp
ut
carr
y;
wir
e[n−
2:0]
c;
assi
gnc
[0]=
g[0
]|
(p[0
]&
cin
);
assi
gnca
rry
=g
[1]
|(p
[1]
&c
[0])
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c3
//F
ile
Nam
e:
c3.v
//F
un
ctio
n:
Ca
rry
Gen
era
tefo
rT
hir
dB
it
134
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
c3(c
in,g
,p,c
arry
);
para
met
ern
=3
;
inp
ut
cin
;
inp
ut
[n−
1:0]
g;
inp
ut
[n−
1:0]
p;
outp
ut
carr
y;
wir
e[n−
2:0]
c;
assi
gnc
[0]=
g[0
]|
(p[0
]&
cin
);
assi
gnc
[1]=
g[1
]|
(p[1
]&
c[0
]);
assi
gnca
rry
=g
[2]
|(p
[2]
&c
[1])
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:g
en_
sig
na
l
//F
ile
Nam
e:
gen
_si
gn
al
.v
//F
un
ctio
n:
Ca
rry
Gen
era
tefo
r4
bit
inth
eC
LAB
lock
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
135
mod
ule
gen
_si
gn
al(g
,p,c
arry
);
para
met
ern
=4
;
inp
ut
[n−
1:0]
g;
inp
ut
[n−
2:0]
p;
outp
ut
carr
y;
wir
e[n−
2:0]
c;
assi
gnc
[0]=
g[0
];
assi
gnc
[1]=
g[1
]|
(p[0
]&
c[0
]);
assi
gnc
[2]=
g[2
]|
(p[1
]&
c[1
]);
assi
gnca
rry
=g
[3]
|(p
[2]
&c
[2])
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:p
rop
_si
gn
al
//F
ile
Nam
e:
pro
p_
sig
na
l.v
//F
un
ctio
n:
Ca
rry
Pro
pa
ga
tefo
r4
bit
int
the
CLA
Blo
ck
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
pro
p_
sig
nal
(p,p
rop
);
para
met
ern
=4
;
inp
ut
[n−
1:0]
p;
136
outp
ut
pro
p;
assi
gnp
rop
=p
[0]
&p
[1]
&p
[2]
&p
[3];
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:su
m
//F
ile
Nam
e:
sum
.v
//F
un
ctio
n:
Fin
ali
zeSu
mfo
rC
LA
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
sum
(a,b
,s);
inp
ut
a;
inp
ut
b;
outp
ut
s;
assi
gns
=a
^b
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:cl
a
//F
ile
Nam
e:
cla
.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
137
mod
ule
cla
(cin
,a,b
,s,g
en,p
rop
);
para
met
ern
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
wir
e[n−
2:0]
carr
y;
wir
e[n−
1:0]
g,p
;
gen
_u
nit
gu0
(.a
(a[0
]),.
b(b
[0])
,.g
(g[0
]));
gen
_u
nit
gu1
(.a
(a[1
]),.
b(b
[1])
,.g
(g[1
]));
gen
_u
nit
gu2
(.a
(a[2
]),.
b(b
[2])
,.g
(g[2
]));
gen
_u
nit
gu3
(.a
(a[3
]),.
b(b
[3])
,.g
(g[3
]));
pro
p_
un
itpu
0(.
a(a
[0])
,.b
(b[0
]),.
p(p
[0])
);
pro
p_
un
itpu
1(.
a(a
[1])
,.b
(b[1
]),.
p(p
[1])
);
pro
p_
un
itpu
2(.
a(a
[2])
,.b
(b[2
]),.
p(p
[2])
);
pro
p_
un
itpu
3(.
a(a
[3])
,.b
(b[3
]),.
p(p
[3])
);
138
c1ca
rry
1(.
cin
(ci
n)
,.g
(g[0
]),.
p(p
[0])
,.ca
rry
(ca
rry
[0])
);
c2ca
rry
2(.
cin
(ci
n)
,.g
(g[1
:0])
,.p
(p[1
:0])
,.ca
rry
(ca
rry
[1])
);
c3ca
rry
3(.
cin
(ci
n)
,.g
(g[2
:0])
,.p
(p[2
:0])
,.ca
rry
(ca
rry
[2])
);
gen
_si
gn
alge
n_su
m(.
g(g
[n−
1:0
]),
.p(p
[n−
1:1
]),
.car
ry(g
en))
;
pro
p_
sig
nal
prop
_sum
(.p
(p[n−
1:0
]),.
pro
p(p
rop
));
sum
sum
0(.
a(
cin
),.
b(p
[0])
,.s
(s[0
]));
sum
sum
1(.
a(
carr
y[0
]),.
b(p
[1])
,.s
(s[1
]));
sum
sum
2(.
a(
carr
y[1
]),.
b(p
[2])
,.s
(s[2
]));
sum
sum
3(.
a(
carr
y[2
]),.
b(p
[3])
,.s
(s[3
]));
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la4
bit
s
//F
ile
Nam
e:
cla
4b
its
.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
4b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=4
;
para
met
erm
=0
;
139
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop
0;
cla
cla
4b
its_
0(.
cin
(ci
n)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en0
),.
pro
p(p
rop
0))
;
assi
gnco
ut
=ge
n0|
(pro
p0
&ci
n);
assi
gnp
rop
=p
rop
0;
assi
gnge
n=
gen0
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la8
bit
s
//F
ile
Nam
e:
cla
8b
its
.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
8b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
8b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
140
para
met
ern
=8
;
para
met
erm
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
4,c
ou
t0,c
ou
t1;
cla
4b
its
cla
8b
its_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
cla
4b
its
cla
8b
its_
1(.
cin
(c4
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc4
=ge
n0|
(pro
p0
&ci
n);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
141
C.4
.2C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
16bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la1
6b
its
//F
ile
Nam
e:
cla
16
bit
s.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
16
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
para
met
ern
=1
6;
para
met
erm
=8
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
8,c
ou
t0,c
ou
t1;
cla
8b
its
cla
16
bit
s_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
142
cla
8b
its
cla
16
bit
s_1
(.ci
n(c
8)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc8
=ge
n0|
(pro
p0
&ci
n);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
C.4
.3C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
32bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la3
2b
its
//F
ile
Nam
e:
cla
32
bit
s.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
32b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
32
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
para
met
ern
=3
2;
para
met
erm
=1
6;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
143
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
16,c
ou
t0,c
ou
t1;
cla
16
bit
sc
la3
2b
its_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
cla
16
bit
sc
la3
2b
its_
1(.
cin
(c16
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc1
6=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
C.4
.4C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
64bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la6
4b
its
//F
ile
Nam
e:
cla
64
bit
s.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
64b
its
144
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
64
bit
s(c
in,a
,b,s
,gen
,pro
p,c
ou
t);
para
met
ern
=6
4;
para
met
erm
=3
2;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
32,c
ou
t0,c
ou
t1;
cla
32
bit
sc
la6
4b
its_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
cla
32
bit
sc
la6
4b
its_
1(.
cin
(c32
),.
a(a
[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc3
2=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
145
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
C.4
.5C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
128
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la1
28
bit
s
//F
ile
Nam
e:
cla
12
8b
its
.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
128
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
12
8b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=1
28
;
para
met
erm
=6
4;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
146
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
64,c
ou
t0,c
ou
t1;
cla
64
bit
sc
la1
28
bit
s_0
(.ci
n(
cin
),.
a(a
[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
cla
64
bit
sc
la1
28
bit
s_1
(.ci
n(c
64)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc6
4=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
C.4
.6C
ódig
oFo
nte
doC
arry
-Loo
kahe
adA
dder
256
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
la2
56
bit
s
//F
ile
Nam
e:
cla
25
6b
its
.v
//F
un
ctio
n:
Ca
rry
Loo
kahe
adA
dder
for
256
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cla
25
6b
its
(cin
,a,b
,s,g
en,p
rop
,co
ut
);
para
met
ern
=2
56
;
147
para
met
erm
=1
28
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
gen
;
outp
ut
pro
p;
outp
ut
cou
t;
wir
ege
n0,p
rop0
,pr
op1
,gen
1,c
128
,co
ut0
,co
ut1
;
cla
12
8b
its
cla
25
6b
its_
0(.
cin
(ci
n)
,.a
(a[m−
1:0
]),.
b(b
[m−
1:0
]),.
s(s
[m−
1:0
])
,.ge
n(g
en0
),.
pro
p(p
rop
0)
,.co
ut(
cou
t0))
;
cla
12
8b
its
cla
25
6b
its_
1(.
cin
(c12
8)
,.a
(a[n−
1:m
]),.
b(b
[n−
1:m
]),.
s(s
[n−
1:m
])
,.ge
n(g
en1
),.
pro
p(p
rop
1)
,.co
ut(
cou
t1))
;
assi
gnc1
28=
gen0
|(p
rop
0&
cin
);
assi
gnco
ut
=ge
n1|
(pro
p1
&ge
n0)
|(p
rop
1&
pro
p0
&ci
n);
assi
gnp
rop
=p
rop
1&
pro
p0
;
assi
gnge
n=
gen1
|(p
rop
1&
gen0
);
endm
odul
e
148
C.5
Cód
igo
Font
edo
Car
ry-S
elec
tAdd
er
C.5
.1C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
8bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:h
alf
_a
dd
er
//F
ile
Nam
e:
ha
lf_
ad
der
.v
//F
un
ctio
n:
Ha
lfA
dder
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
hal
f_ad
der
(a,b
,s,c
ou
t);
inp
ut
a,b
;
outp
ut
s,c
ou
t;
assi
gns
=a
^b
;
assi
gnco
ut
=(a
&b
);
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:h
alf
_a
dd
erci
n1
//F
ile
Nam
e:
ha
lf_
ad
der
cin
1.v
//F
un
ctio
n:
Ha
lfA
dder
Wit
hC
IN1
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
149
mod
ule
ha
lf_
ad
de
rcin
1(a
,b,s
,co
ut
);
inp
ut
a,b
;
outp
ut
s,c
ou
t;
assi
gns
=~
(a^
b);
assi
gnco
ut
=a
|b
;
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra4
bit
scin
0
//F
ile
Nam
e:
cra
4b
itsc
in0
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
4b
its
Wit
hC
IN0
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
4b
itsc
in0
(a,b
,s,c
ou
t);
para
met
ern
=4
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[n−
2:0]
c;
150
hal
f_ad
der
cra4
_0
(.a
(a[0
]),.
b(b
[0])
,.s
(s[0
]),.
cou
t(c
[0])
);
full
_a
dd
er
cra4
_1
(.ci
n(c
[0])
,.a
(a[1
]),.
b(b
[1])
,.s
(s[1
]),.
cou
t(c
[1])
);
full
_a
dd
er
cra4
_2
(.ci
n(c
[1])
,.a
(a[2
]),.
b(b
[2])
,.s
(s[2
]),.
cou
t(c
[2])
);
full
_a
dd
er
cra4
_3
(.ci
n(c
[2])
,.a
(a[3
]),.
b(b
[3])
,.s
(s[3
]),.
cou
t(co
ut
));
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
ra4
bit
scin
1
//F
ile
Nam
e:
cra
4b
itsc
in1
.v
//F
un
ctio
n:
Ca
rry
Rip
ple
Add
erto
4b
its
Wit
hC
IN1
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
cra
4b
itsc
in1
(a,b
,s,c
ou
t);
para
met
ern
=4
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[n−
2:0]
c;
ha
lf_
ad
de
rcin
1cr
a4_
0(.
a(a
[0])
,.b
(b[0
]),.
s(s
[0])
,.co
ut(
c[0
]));
full
_a
dd
er
cra4
_1
(.ci
n(c
[0])
,.a
(a[1
]),.
b(b
[1])
,.s
(s[1
]),.
cou
t(c
[1])
);
151
full
_a
dd
er
cra4
_2
(.ci
n(c
[1])
,.a
(a[2
]),.
b(b
[2])
,.s
(s[2
]),.
cou
t(c
[2])
);
full
_a
dd
er
cra4
_3
(.ci
n(c
[2])
,.a
(a[3
]),.
b(b
[3])
,.s
(s[3
]),.
cou
t(co
ut
));
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:cs
a
//F
ile
Nam
e:
csa
.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
4b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
(se
l,a
,b,s
,c0
,c1
);
para
met
ern
=4
;
inp
ut
sel
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
c0;
outp
ut
c1;
wir
e[n−
1:0]
sum
0,s
um1
;
cra
4b
itsc
in0
csa_
0(.
a(a
[n−
1:0
]),.
b(b
[n−
1:0
]),.
s(s
um0
[n−
1:0
]),.
cou
t(c0
));
cra
4b
itsc
in1
csa_
1(.
a(a
[n−
1:0
]),.
b(b
[n−
1:0
]),.
s(s
um1
[n−
1:0
]),.
cou
t(c1
));
152
mux
2to1
m1
(.se
l(se
l)
,.a
(sum
1[0
]),.
b(s
um0
[0])
,.o
ut(
s[0
]));
mux
2to1
m2
(.se
l(se
l)
,.a
(sum
1[1
]),.
b(s
um0
[1])
,.o
ut(
s[1
]));
mux
2to1
m3
(.se
l(se
l)
,.a
(sum
1[2
]),.
b(s
um0
[2])
,.o
ut(
s[2
]));
mux
2to1
m4
(.se
l(se
l)
,.a
(sum
1[3
]),.
b(s
um0
[3])
,.o
ut(
s[3
]));
endm
odul
e
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa8
bit
s
//F
ile
Nam
e:
csa
8b
its
.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
8b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=8
;
para
met
erm
=2
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
c0,c
1,s
el
;
153
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
assi
gnco
ut
=c0
[0]
|(c
1[0
]&
sel
[0])
;
endm
odul
e
C.5
.2C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
16bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa1
6b
its
//F
ile
Nam
e:
csa
16
bit
s.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
16b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
16
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=1
6;
para
met
erm
=4
;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
154
wir
e[m−
2:0]
c0,c
1,s
el
;
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
csa
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
]),.
c0(c
0[1
]),.
c1(c
1[1
]));
csa
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.c0
(c0
[2])
,.c1
(c1
[2])
);
assi
gnse
l[1
]=
c0[0
]|
(c1
[0]
&se
l[0
]);
assi
gnse
l[2
]=
c0[1
]|
(c1
[1]
&se
l[1
]);
assi
gnco
ut
=c0
[2]
|(c
1[2
]&
sel
[2])
;
endm
odul
e
C.5
.3C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
32bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa3
2b
its
//F
ile
Nam
e:
csa
32
bit
s.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
32b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
32
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=3
2;
para
met
erm
=8
;
155
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
c0,c
1,s
el
;
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
csa
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
]),.
c0(c
0[1
]),.
c1(c
1[1
]));
csa
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.c0
(c0
[2])
,.c1
(c1
[2])
);
csa
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.c0
(c0
[3])
,.c1
(c1
[3])
);
csa
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.c0
(c0
[4])
,.c1
(c1
[4])
);
csa
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.c0
(c0
[5])
,.c1
(c1
[5])
);
csa
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.c0
(c0
[6])
,.c1
(c1
[6])
);
assi
gnse
l[1
]=
c0[0
]|
(c1
[0]
&se
l[0
]);
assi
gnse
l[2
]=
c0[1
]|
(c1
[1]
&se
l[1
]);
assi
gnse
l[3
]=
c0[2
]|
(c1
[2]
&se
l[2
]);
assi
gnse
l[4
]=
c0[3
]|
(c1
[3]
&se
l[3
]);
assi
gnse
l[5
]=
c0[4
]|
(c1
[4]
&se
l[4
]);
156
assi
gnse
l[6
]=
c0[5
]|
(c1
[5]
&se
l[5
]);
assi
gnco
ut
=c0
[6]
|(c
1[6
]&
sel
[6])
;
endm
odul
e
C.5
.4C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
64bi
ts
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa6
4b
its
//F
ile
Nam
e:
csa
64
bit
s.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
64b
its
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
64
bit
s(c
in,a
,b,s
,co
ut
);
para
met
ern
=6
4;
para
met
erm
=1
6;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
c0,c
1,s
el
;
157
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
csa
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
]),.
c0(c
0[1
])
,.c1
(c1
[1])
);
csa
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.c0
(c0
[2])
,.c1
(c1
[2])
);
csa
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.c0
(c0
[3])
,.c1
(c1
[3])
);
csa
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.c0
(c0
[4])
,.c1
(c1
[4])
);
csa
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.c0
(c0
[5])
,.c1
(c1
[5])
);
csa
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.c0
(c0
[6])
,.c1
(c1
[6])
);
csa
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.c0
(c0
[7])
,.c1
(c1
[7])
);
csa
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.c0
(c0
[8])
,.c1
(c1
[8])
);
csa
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
]),.
c0(c
0[9
])
,.c1
(c1
[9])
);
csa
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.c0
(c0
[10
])
,.c1
(c1
[10
]));
158
csa
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.c0
(c0
[11
])
,.c1
(c1
[11
]));
csa
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.c0
(c0
[12
])
,.c1
(c1
[12
]));
csa
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.c0
(c0
[13
])
,.c1
(c1
[13
]));
csa
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.c0
(c0
[14
])
,.c1
(c1
[14
]));
assi
gnse
l[1
]=
c0[0
]|
(c1
[0]
&se
l[0
]);
assi
gnse
l[2
]=
c0[1
]|
(c1
[1]
&se
l[1
]);
assi
gnse
l[3
]=
c0[2
]|
(c1
[2]
&se
l[2
]);
assi
gnse
l[4
]=
c0[3
]|
(c1
[3]
&se
l[3
]);
assi
gnse
l[5
]=
c0[4
]|
(c1
[4]
&se
l[4
]);
assi
gnse
l[6
]=
c0[5
]|
(c1
[5]
&se
l[5
]);
assi
gnse
l[7
]=
c0[6
]|
(c1
[6]
&se
l[6
]);
assi
gnse
l[8
]=
c0[7
]|
(c1
[7]
&se
l[7
]);
assi
gnse
l[9
]=
c0[8
]|
(c1
[8]
&se
l[8
]);
assi
gnse
l[1
0]
=c0
[9]
|(c
1[9
]&
sel
[9])
;
assi
gnse
l[1
1]
=c0
[10
]|
(c1
[10
]&
sel
[10
]);
assi
gnse
l[1
2]
=c0
[11
]|
(c1
[11
]&
sel
[11
]);
assi
gnse
l[1
3]
=c0
[12
]|
(c1
[12
]&
sel
[12
]);
assi
gnse
l[1
4]
=c0
[13
]|
(c1
[13
]&
sel
[13
]);
159
assi
gnco
ut
=c0
[14
]|
(c1
[14
]&
sel
[14
]);
endm
odul
e
C.5
.5C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
128
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa1
28
bit
s
//F
ile
Nam
e:
csa
12
8b
its
.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
128
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
12
8b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=1
28
;
para
met
erm
=3
2;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
c0,c
1,s
el
;
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
160
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
csa
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
]),.
c0(c
0[1
])
,.c1
(c1
[1])
);
csa
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.c0
(c0
[2])
,.c1
(c1
[2])
);
csa
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.c0
(c0
[3])
,.c1
(c1
[3])
);
csa
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.c0
(c0
[4])
,.c1
(c1
[4])
);
csa
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.c0
(c0
[5])
,.c1
(c1
[5])
);
csa
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.c0
(c0
[6])
,.c1
(c1
[6])
);
csa
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.c0
(c0
[7])
,.c1
(c1
[7])
);
csa
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.c0
(c0
[8])
,.c1
(c1
[8])
);
csa
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
]),.
c0(c
0[9
])
,.c1
(c1
[9])
);
csa
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.c0
(c0
[10
])
,.c1
(c1
[10
]));
csa
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.c0
(c0
[11
])
161
,.c1
(c1
[11
]));
csa
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.c0
(c0
[12
])
,.c1
(c1
[12
]));
csa
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.c0
(c0
[13
])
,.c1
(c1
[13
]));
csa
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.c0
(c0
[14
])
,.c1
(c1
[14
]));
csa
csa_
16
(.se
l(se
l[1
5])
,.a
(a[6
7:6
4])
,.b
(b[6
7:6
4])
,.s
(s[6
7:6
4])
,.c0
(c0
[15
])
,.c1
(c1
[15
]));
csa
csa_
17
(.se
l(se
l[1
6])
,.a
(a[7
1:6
8])
,.b
(b[7
1:6
8])
,.s
(s[7
1:6
8])
,.c0
(c0
[16
])
,.c1
(c1
[16
]));
csa
csa_
18
(.se
l(se
l[1
7])
,.a
(a[7
5:7
2])
,.b
(b[7
5:7
2])
,.s
(s[7
5:7
2])
,.c0
(c0
[17
])
,.c1
(c1
[17
]));
csa
csa_
19
(.se
l(se
l[1
8])
,.a
(a[7
9:7
6])
,.b
(b[7
9:7
6])
,.s
(s[7
9:7
6])
,.c0
(c0
[18
])
,.c1
(c1
[18
]));
csa
csa_
20
(.se
l(se
l[1
9])
,.a
(a[8
3:8
0])
,.b
(b[8
3:8
0])
,.s
(s[8
3:8
0])
,.c0
(c0
[19
])
,.c1
(c1
[19
]));
csa
csa_
21
(.se
l(se
l[2
0])
,.a
(a[8
7:8
4])
,.b
(b[8
7:8
4])
,.s
(s[8
7:8
4])
,.c0
(c0
[20
])
,.c1
(c1
[20
]));
csa
csa_
22
(.se
l(se
l[2
1])
,.a
(a[9
1:8
8])
,.b
(b[9
1:8
8])
,.s
(s[9
1:8
8])
,.c0
(c0
[21
])
,.c1
(c1
[21
]));
csa
csa_
23
(.se
l(se
l[2
2])
,.a
(a[9
5:9
2])
,.b
(b[9
5:9
2])
,.s
(s[9
5:9
2])
,.c0
(c0
[22
])
,.c1
(c1
[22
]));
162
csa
csa_
24
(.se
l(se
l[2
3])
,.a
(a[9
9:9
6])
,.b
(b[9
9:9
6])
,.s
(s[9
9:9
6])
,.c0
(c0
[23
])
,.c1
(c1
[23
]));
csa
csa_
25
(.se
l(se
l[2
4])
,.a
(a[1
03
:10
0])
,.b
(b[1
03
:10
0])
,.s
(s[1
03
:10
0])
,.c0
(c0
[24
])
,.c1
(c1
[24
]));
csa
csa_
26
(.se
l(se
l[2
5])
,.a
(a[1
07
:10
4])
,.b
(b[1
07
:10
4])
,.s
(s[1
07
:10
4])
,.c0
(c0
[25
])
,.c1
(c1
[25
]));
csa
csa_
27
(.se
l(se
l[2
6])
,.a
(a[1
11
:10
8])
,.b
(b[1
11
:10
8])
,.s
(s[1
11
:10
8])
,.c0
(c0
[26
])
,.c1
(c1
[26
]));
csa
csa_
28
(.se
l(se
l[2
7])
,.a
(a[1
15
:11
2])
,.b
(b[1
15
:11
2])
,.s
(s[1
15
:11
2])
,.c0
(c0
[27
])
,.c1
(c1
[27
]));
csa
csa_
29
(.se
l(se
l[2
8])
,.a
(a[1
19
:11
6])
,.b
(b[1
19
:11
6])
,.s
(s[1
19
:11
6])
,.c0
(c0
[28
])
,.c1
(c1
[28
]));
csa
csa_
30
(.se
l(se
l[2
9])
,.a
(a[1
23
:12
0])
,.b
(b[1
23
:12
0])
,.s
(s[1
23
:12
0])
,.c0
(c0
[29
])
,.c1
(c1
[29
]));
csa
csa_
31
(.se
l(se
l[3
0])
,.a
(a[1
27
:12
4])
,.b
(b[1
27
:12
4])
,.s
(s[1
27
:12
4])
,.c0
(c0
[30
])
,.c1
(c1
[30
]));
assi
gnse
l[1
]=
c0[0
]|
(c1
[0]
&se
l[0
]);
assi
gnse
l[2
]=
c0[1
]|
(c1
[1]
&se
l[1
]);
assi
gnse
l[3
]=
c0[2
]|
(c1
[2]
&se
l[2
]);
assi
gnse
l[4
]=
c0[3
]|
(c1
[3]
&se
l[3
]);
assi
gnse
l[5
]=
c0[4
]|
(c1
[4]
&se
l[4
]);
assi
gnse
l[6
]=
c0[5
]|
(c1
[5]
&se
l[5
]);
163
assi
gnse
l[7
]=
c0[6
]|
(c1
[6]
&se
l[6
]);
assi
gnse
l[8
]=
c0[7
]|
(c1
[7]
&se
l[7
]);
assi
gnse
l[9
]=
c0[8
]|
(c1
[8]
&se
l[8
]);
assi
gnse
l[1
0]
=c0
[9]
|(c
1[9
]&
sel
[9])
;
assi
gnse
l[1
1]
=c0
[10
]|
(c1
[10
]&
sel
[10
]);
assi
gnse
l[1
2]
=c0
[11
]|
(c1
[11
]&
sel
[11
]);
assi
gnse
l[1
3]
=c0
[12
]|
(c1
[12
]&
sel
[12
]);
assi
gnse
l[1
4]
=c0
[13
]|
(c1
[13
]&
sel
[13
]);
assi
gnse
l[1
5]
=c0
[14
]|
(c1
[14
]&
sel
[14
]);
assi
gnse
l[1
6]
=c0
[15
]|
(c1
[15
]&
sel
[15
]);
assi
gnse
l[1
7]
=c0
[16
]|
(c1
[16
]&
sel
[16
]);
assi
gnse
l[1
8]
=c0
[17
]|
(c1
[17
]&
sel
[17
]);
assi
gnse
l[1
9]
=c0
[18
]|
(c1
[18
]&
sel
[18
]);
assi
gnse
l[2
0]
=c0
[19
]|
(c1
[19
]&
sel
[19
]);
assi
gnse
l[2
1]
=c0
[20
]|
(c1
[20
]&
sel
[20
]);
assi
gnse
l[2
2]
=c0
[21
]|
(c1
[21
]&
sel
[21
]);
assi
gnse
l[2
3]
=c0
[22
]|
(c1
[22
]&
sel
[22
]);
assi
gnse
l[2
4]
=c0
[23
]|
(c1
[23
]&
sel
[23
]);
assi
gnse
l[2
5]
=c0
[24
]|
(c1
[24
]&
sel
[24
]);
assi
gnse
l[2
6]
=c0
[25
]|
(c1
[25
]&
sel
[25
]);
assi
gnse
l[2
7]
=c0
[26
]|
(c1
[26
]&
sel
[26
]);
assi
gnse
l[2
8]
=c0
[27
]|
(c1
[27
]&
sel
[27
]);
assi
gnse
l[2
9]
=c0
[28
]|
(c1
[28
]&
sel
[28
]);
164
assi
gnse
l[3
0]
=c0
[29
]|
(c1
[29
]&
sel
[29
]);
assi
gnco
ut
=c0
[30
]|
(c1
[30
]&
sel
[30
]);
endm
odul
e
C.5
.6C
ódig
oFo
nte
doC
arry
-Sel
ectA
dder
256
bits
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
//D
esig
nN
ame
:c
sa2
56
bit
s
//F
ile
Nam
e:
csa
25
6b
its
.v
//F
un
ctio
n:
Ca
rry
Se
lec
tA
dder
for
256
bit
s
//C
oder
:Ju
cem
arM
on
teir
o
//−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
mod
ule
csa
25
6b
its
(cin
,a,b
,s,c
ou
t);
para
met
ern
=2
56
;
para
met
erm
=6
4;
inp
ut
cin
;
inp
ut
[n−
1:0]
a;
inp
ut
[n−
1:0]
b;
outp
ut
[n−
1:0]
s;
outp
ut
cou
t;
wir
e[m−
2:0]
c0,c
1,s
el
;
165
cra
4b
its
csa_
0(.
cin
(ci
n)
,.a
(a[3
:0])
,.b
(b[3
:0])
,.s
(s[3
:0])
,.co
ut(
sel
[0])
);
csa
csa_
1(.
sel(
sel
[0])
,.a
(a[7
:4])
,.b
(b[7
:4])
,.s
(s[7
:4])
,.c0
(c0
[0])
,.c1
(c1
[0])
);
csa
csa_
2(.
sel(
sel
[1])
,.a
(a[1
1:8
]),.
b(b
[11
:8])
,.s
(s[1
1:8
]),.
c0(c
0[1
])
,.c1
(c1
[1])
);
csa
csa_
3(.
sel(
sel
[2])
,.a
(a[1
5:1
2])
,.b
(b[1
5:1
2])
,.s
(s[1
5:1
2])
,.c0
(c0
[2])
,.c1
(c1
[2])
);
csa
csa_
4(.
sel(
sel
[3])
,.a
(a[1
9:1
6])
,.b
(b[1
9:1
6])
,.s
(s[1
9:1
6])
,.c0
(c0
[3])
,.c1
(c1
[3])
);
csa
csa_
5(.
sel(
sel
[4])
,.a
(a[2
3:2
0])
,.b
(b[2
3:2
0])
,.s
(s[2
3:2
0])
,.c0
(c0
[4])
,.c1
(c1
[4])
);
csa
csa_
6(.
sel(
sel
[5])
,.a
(a[2
7:2
4])
,.b
(b[2
7:2
4])
,.s
(s[2
7:2
4])
,.c0
(c0
[5])
,.c1
(c1
[5])
);
csa
csa_
7(.
sel(
sel
[6])
,.a
(a[3
1:2
8])
,.b
(b[3
1:2
8])
,.s
(s[3
1:2
8])
,.c0
(c0
[6])
,.c1
(c1
[6])
);
csa
csa_
8(.
sel(
sel
[7])
,.a
(a[3
5:3
2])
,.b
(b[3
5:3
2])
,.s
(s[3
5:3
2])
,.c0
(c0
[7])
,.c1
(c1
[7])
);
csa
csa_
9(.
sel(
sel
[8])
,.a
(a[3
9:3
6])
,.b
(b[3
9:3
6])
,.s
(s[3
9:3
6])
,.c0
(c0
[8])
,.c1
(c1
[8])
);
csa
csa_
10
(.se
l(se
l[9
]),.
a(a
[43
:40
]),.
b(b
[43
:40
]),.
s(s
[43
:40
]),.
c0(c
0[9
])
,.c1
(c1
[9])
);
csa
csa_
11
(.se
l(se
l[1
0])
,.a
(a[4
7:4
4])
,.b
(b[4
7:4
4])
,.s
(s[4
7:4
4])
,.c0
(c0
[10
])
,.c1
(c1
[10
]));
166
csa
csa_
12
(.se
l(se
l[1
1])
,.a
(a[5
1:4
8])
,.b
(b[5
1:4
8])
,.s
(s[5
1:4
8])
,.c0
(c0
[11
])
,.c1
(c1
[11
]));
csa
csa_
13
(.se
l(se
l[1
2])
,.a
(a[5
5:5
2])
,.b
(b[5
5:5
2])
,.s
(s[5
5:5
2])
,.c0
(c0
[12
])
,.c1
(c1
[12
]));
csa
csa_
14
(.se
l(se
l[1
3])
,.a
(a[5
9:5
6])
,.b
(b[5
9:5
6])
,.s
(s[5
9:5
6])
,.c0
(c0
[13
])
,.c1
(c1
[13
]));
csa
csa_
15
(.se
l(se
l[1
4])
,.a
(a[6
3:6
0])
,.b
(b[6
3:6
0])
,.s
(s[6
3:6
0])
,.c0
(c0
[14
])
,.c1
(c1
[14
]));
csa
csa_
16
(.se
l(se
l[1
5])
,.a
(a[6
7:6
4])
,.b
(b[6
7:6
4])
,.s
(s[6
7:6
4])
,.c0
(c0
[15
])
,.c1
(c1
[15
]));
csa
csa_
17
(.se
l(se
l[1
6])
,.a
(a[7
1:6
8])
,.b
(b[7
1:6
8])
,.s
(s[7
1:6
8])
,.c0
(c0
[16
])
,.c1
(c1
[16
]));
csa
csa_
18
(.se
l(se
l[1
7])
,.a
(a[7
5:7
2])
,.b
(b[7
5:7
2])
,.s
(s[7
5:7
2])
,.c0
(c0
[17
])
,.c1
(c1
[17
]));
csa
csa_
19
(.se
l(se
l[1
8])
,.a
(a[7
9:7
6])
,.b
(b[7
9:7
6])
,.s
(s[7
9:7
6])
,.c0
(c0
[18
])
,.c1
(c1
[18
]));
csa
csa_
20
(.se
l(se
l[1
9])
,.a
(a[8
3:8
0])
,.b
(b[8
3:8
0])
,.s
(s[8
3:8
0])
,.c0
(c0
[19
])
,.c1
(c1
[19
]));
csa
csa_
21
(.se
l(se
l[2
0])
,.a
(a[8
7:8
4])
,.b
(b[8
7:8
4])
,.s
(s[8
7:8
4])
,.c0
(c0
[20
])
,.c1
(c1
[20
]));
csa
csa_
22
(.se
l(se
l[2
1])
,.a
(a[9
1:8
8])
,.b
(b[9
1:8
8])
,.s
(s[9
1:8
8])
,.c0
(c0
[21
])
,.c1
(c1
[21
]));
csa
csa_
23
(.se
l(se
l[2
2])
,.a
(a[9
5:9
2])
,.b
(b[9
5:9
2])
,.s
(s[9
5:9
2])
,.c0
(c0
[22
])
167
,.c1
(c1
[22
]));
csa
csa_
24
(.se
l(se
l[2
3])
,.a
(a[9
9:9
6])
,.b
(b[9
9:9
6])
,.s
(s[9
9:9
6])
,.c0
(c0
[23
])
,.c1
(c1
[23
]));
csa
csa_
25
(.se
l(se
l[2
4])
,.a
(a[1
03
:10
0])
,.b
(b[1
03
:10
0])
,.s
(s[1
03
:10
0])
,.c0
(c0
[24
])
,.c1
(c1
[24
]));
csa
csa_
26
(.se
l(se
l[2
5])
,.a
(a[1
07
:10
4])
,.b
(b[1
07
:10
4])
,.s
(s[1
07
:10
4])
,.c0
(c0
[25
])
,.c1
(c1
[25
]));
csa
csa_
27
(.se
l(se
l[2
6])
,.a
(a[1
11
:10
8])
,.b
(b[1
11
:10
8])
,.s
(s[1
11
:10
8])
,.c0
(c0
[26
])
,.c1
(c1
[26
]));
csa
csa_
28
(.se
l(se
l[2
7])
,.a
(a[1
15
:11
2])
,.b
(b[1
15
:11
2])
,.s
(s[1
15
:11
2])
,.c0
(c0
[27
])
,.c1
(c1
[27
]));
csa
csa_
29
(.se
l(se
l[2
8])
,.a
(a[1
19
:11
6])
,.b
(b[1
19
:11
6])
,.s
(s[1
19
:11
6])
,.c0
(c0
[28
])
,.c1
(c1
[28
]));
csa
csa_
30
(.se
l(se
l[2
9])
,.a
(a[1
23
:12
0])
,.b
(b[1
23
:12
0])
,.s
(s[1
23
:12
0])
,.c0
(c0
[29
])
,.c1
(c1
[29
]));
csa
csa_
31
(.se
l(se
l[3
0])
,.a
(a[1
27
:12
4])
,.b
(b[1
27
:12
4])
,.s
(s[1
27
:12
4])
,.c0
(c0
[30
])
,.c1
(c1
[30
]));
csa
csa_
32
(.se
l(se
l[3
1])
,.a
(a[1
31
:12
8])
,.b
(b[1
31
:12
8])
,.s
(s[1
31
:12
8])
,.c0
(c0
[31
])
,.c1
(c1
[31
]));
csa
csa_
33
(.se
l(se
l[3
2])
,.a
(a[1
35
:13
2])
,.b
(b[1
35
:13
2])
,.s
(s[1
35
:13
2])
,.c0
(c0
[32
])
,.c1
(c1
[32
]));
csa
csa_
34
(.se
l(se
l[3
3])
,.a
(a[1
39
:13
6])
,.b
(b[1
39
:13
6])
,.s
(s[1
39
:13
6])
,.c0
(c0
[33
])
,.c1
(c1
[33
]));
168
csa
csa_
35
(.se
l(se
l[3
4])
,.a
(a[1
43
:14
0])
,.b
(b[1
43
:14
0])
,.s
(s[1
43
:14
0])
,.c0
(c0
[34
])
,.c1
(c1
[34
]));
csa
csa_
36
(.se
l(se
l[3
5])
,.a
(a[1
47
:14
4])
,.b
(b[1
47
:14
4])
,.s
(s[1
47
:14
4])
,.c0
(c0
[35
])
,.c1
(c1
[35
]));
csa
csa_
37
(.se
l(se
l[3
6])
,.a
(a[1
51
:14
8])
,.b
(b[1
51
:14
8])
,.s
(s[1
51
:14
8])
,.c0
(c0
[36
])
,.c1
(c1
[36
]));
csa
csa_
38
(.se
l(se
l[3
7])
,.a
(a[1
55
:15
2])
,.b
(b[1
55
:15
2])
,.s
(s[1
55
:15
2])
,.c0
(c0
[37
])
,.c1
(c1
[37
]));
csa
csa_
39
(.se
l(se
l[3
8])
,.a
(a[1
59
:15
6])
,.b
(b[1
59
:15
6])
,.s
(s[1
59
:15
6])
,.c0
(c0
[38
])
,.c1
(c1
[38
]));
csa
csa_
40
(.se
l(se
l[3
9])
,.a
(a[1
63
:16
0])
,.b
(b[1
63
:16
0])
,.s
(s[1
63
:16
0])
,.c0
(c0
[39
])
,.c1
(c1
[39
]));
csa
csa_
41
(.se
l(se
l[4
0])
,.a
(a[1
67
:16
4])
,.b
(b[1
67
:16
4])
,.s
(s[1
67
:16
4])
,.c0
(c0
[40
])
,.c1
(c1
[40
]));
csa
csa_
42
(.se
l(se
l[4
1])
,.a
(a[1
71
:16
8])
,.b
(b[1
71
:16
8])
,.s
(s[1
71
:16
8])
,.c0
(c0
[41
])
,.c1
(c1
[41
]));
csa
csa_
43
(.se
l(se
l[4
2])
,.a
(a[1
75
:17
2])
,.b
(b[1
75
:17
2])
,.s
(s[1
75
:17
2])
,.c0
(c0
[42
])
,.c1
(c1
[42
]));
csa
csa_
44
(.se
l(se
l[4
3])
,.a
(a[1
79
:17
6])
,.b
(b[1
79
:17
6])
,.s
(s[1
79
:17
6])
,.c0
(c0
[43
])
,.c1
(c1
[43
]));
csa
csa_
45
(.se
l(se
l[4
4])
,.a
(a[1
83
:18
0])
,.b
(b[1
83
:18
0])
,.s
(s[1
83
:18
0])
,.c0
(c0
[44
])
,.c1
(c1
[44
]));
csa
csa_
46
(.se
l(se
l[4
5])
,.a
(a[1
87
:18
4])
,.b
(b[1
87
:18
4])
,.s
(s[1
87
:18
4])
,.c0
(c0
[45
])
169
,.c1
(c1
[45
]));
csa
csa_
47
(.se
l(se
l[4
6])
,.a
(a[1
91
:18
8])
,.b
(b[1
91
:18
8])
,.s
(s[1
91
:18
8])
,.c0
(c0
[46
])
,.c1
(c1
[46
]));
csa
csa_
48
(.se
l(se
l[4
7])
,.a
(a[1
95
:19
2])
,.b
(b[1
95
:19
2])
,.s
(s[1
95
:19
2])
,.c0
(c0
[47
])
,.c1
(c1
[47
]));
csa
csa_
49
(.se
l(se
l[4
8])
,.a
(a[1
99
:19
6])
,.b
(b[1
99
:19
6])
,.s
(s[1
99
:19
6])
,.c0
(c0
[48
])
,.c1
(c1
[48
]));
csa
csa_
50
(.se
l(se
l[4
9])
,.a
(a[2
03
:20
0])
,.b
(b[2
03
:20
0])
,.s
(s[2
03
:20
0])
,.c0
(c0
[49
])
,.c1
(c1
[49
]));
csa
csa_
51
(.se
l(se
l[5
0])
,.a
(a[2
07
:20
4])
,.b
(b[2
07
:20
4])
,.s
(s[2
07
:20
4])
,.c0
(c0
[50
])
,.c1
(c1
[50
]));
csa
csa_
52
(.se
l(se
l[5
1])
,.a
(a[2
11
:20
8])
,.b
(b[2
11
:20
8])
,.s
(s[2
11
:20
8])
,.c0
(c0
[51
])
,.c1
(c1
[51
]));
csa
csa_
53
(.se
l(se
l[5
2])
,.a
(a[2
15
:21
2])
,.b
(b[2
15
:21
2])
,.s
(s[2
15
:21
2])
,.c0
(c0
[52
])
,.c1
(c1
[52
]));
csa
csa_
54
(.se
l(se
l[5
3])
,.a
(a[2
19
:21
6])
,.b
(b[2
19
:21
6])
,.s
(s[2
19
:21
6])
,.c0
(c0
[53
])
,.c1
(c1
[53
]));
csa
csa_
55
(.se
l(se
l[5
4])
,.a
(a[2
23
:22
0])
,.b
(b[2
23
:22
0])
,.s
(s[2
23
:22
0])
,.c0
(c0
[54
])
,.c1
(c1
[54
]));
csa
csa_
56
(.se
l(se
l[5
5])
,.a
(a[2
27
:22
4])
,.b
(b[2
27
:22
4])
,.s
(s[2
27
:22
4])
,.c0
(c0
[55
])
,.c1
(c1
[55
]));
csa
csa_
57
(.se
l(se
l[5
6])
,.a
(a[2
31
:22
8])
,.b
(b[2
31
:22
8])
,.s
(s[2
31
:22
8])
,.c0
(c0
[56
])
,.c1
(c1
[56
]));
170
csa
csa_
58
(.se
l(se
l[5
7])
,.a
(a[2
35
:23
2])
,.b
(b[2
35
:23
2])
,.s
(s[2
35
:23
2])
,.c0
(c0
[57
])
,.c1
(c1
[57
]));
csa
csa_
59
(.se
l(se
l[5
8])
,.a
(a[2
39
:23
6])
,.b
(b[2
39
:23
6])
,.s
(s[2
39
:23
6])
,.c0
(c0
[58
])
,.c1
(c1
[58
]));
csa
csa_
60
(.se
l(se
l[5
9])
,.a
(a[2
43
:24
0])
,.b
(b[2
43
:24
0])
,.s
(s[2
43
:24
0])
,.c0
(c0
[59
])
,.c1
(c1
[59
]));
csa
csa_
61
(.se
l(se
l[6
0])
,.a
(a[2
47
:24
4])
,.b
(b[2
47
:24
4])
,.s
(s[2
47
:24
4])
,.c0
(c0
[60
])
,.c1
(c1
[60
]));
csa
csa_
62
(.se
l(se
l[6
1])
,.a
(a[2
51
:24
8])
,.b
(b[2
51
:24
8])
,.s
(s[2
51
:24
8])
,.c0
(c0
[61
])
,.c1
(c1
[61
]));
csa
csa_
63
(.se
l(se
l[6
2])
,.a
(a[2
55
:25
2])
,.b
(b[2
55
:25
2])
,.s
(s[2
55
:25
2])
,.c0
(c0
[62
])
,.c1
(c1
[62
]));
assi
gnse
l[1
]=
c0[0
]|
(c1
[0]
&se
l[0
]);
assi
gnse
l[2
]=
c0[1
]|
(c1
[1]
&se
l[1
]);
assi
gnse
l[3
]=
c0[2
]|
(c1
[2]
&se
l[2
]);
assi
gnse
l[4
]=
c0[3
]|
(c1
[3]
&se
l[3
]);
assi
gnse
l[5
]=
c0[4
]|
(c1
[4]
&se
l[4
]);
assi
gnse
l[6
]=
c0[5
]|
(c1
[5]
&se
l[5
]);
assi
gnse
l[7
]=
c0[6
]|
(c1
[6]
&se
l[6
]);
assi
gnse
l[8
]=
c0[7
]|
(c1
[7]
&se
l[7
]);
assi
gnse
l[9
]=
c0[8
]|
(c1
[8]
&se
l[8
]);
assi
gnse
l[1
0]
=c0
[9]
|(c
1[9
]&
sel
[9])
;
171
assi
gnse
l[1
1]
=c0
[10
]|
(c1
[10
]&
sel
[10
]);
assi
gnse
l[1
2]
=c0
[11
]|
(c1
[11
]&
sel
[11
]);
assi
gnse
l[1
3]
=c0
[12
]|
(c1
[12
]&
sel
[12
]);
assi
gnse
l[1
4]
=c0
[13
]|
(c1
[13
]&
sel
[13
]);
assi
gnse
l[1
5]
=c0
[14
]|
(c1
[14
]&
sel
[14
]);
assi
gnse
l[1
6]
=c0
[15
]|
(c1
[15
]&
sel
[15
]);
assi
gnse
l[1
7]
=c0
[16
]|
(c1
[16
]&
sel
[16
]);
assi
gnse
l[1
8]
=c0
[17
]|
(c1
[17
]&
sel
[17
]);
assi
gnse
l[1
9]
=c0
[18
]|
(c1
[18
]&
sel
[18
]);
assi
gnse
l[2
0]
=c0
[19
]|
(c1
[19
]&
sel
[19
]);
assi
gnse
l[2
1]
=c0
[20
]|
(c1
[20
]&
sel
[20
]);
assi
gnse
l[2
2]
=c0
[21
]|
(c1
[21
]&
sel
[21
]);
assi
gnse
l[2
3]
=c0
[22
]|
(c1
[22
]&
sel
[22
]);
assi
gnse
l[2
4]
=c0
[23
]|
(c1
[23
]&
sel
[23
]);
assi
gnse
l[2
5]
=c0
[24
]|
(c1
[24
]&
sel
[24
]);
assi
gnse
l[2
6]
=c0
[25
]|
(c1
[25
]&
sel
[25
]);
assi
gnse
l[2
7]
=c0
[26
]|
(c1
[26
]&
sel
[26
]);
assi
gnse
l[2
8]
=c0
[27
]|
(c1
[27
]&
sel
[27
]);
assi
gnse
l[2
9]
=c0
[28
]|
(c1
[28
]&
sel
[28
]);
assi
gnse
l[3
0]
=c0
[29
]|
(c1
[29
]&
sel
[29
]);
assi
gnse
l[3
1]
=c0
[30
]|
(c1
[30
]&
sel
[30
]);
assi
gnse
l[3
2]
=c0
[31
]|
(c1
[31
]&
sel
[31
]);
assi
gnse
l[3
3]
=c0
[32
]|
(c1
[32
]&
sel
[32
]);
172
assi
gnse
l[3
4]
=c0
[33
]|
(c1
[33
]&
sel
[33
]);
assi
gnse
l[3
5]
=c0
[34
]|
(c1
[34
]&
sel
[34
]);
assi
gnse
l[3
6]
=c0
[35
]|
(c1
[35
]&
sel
[35
]);
assi
gnse
l[3
7]
=c0
[36
]|
(c1
[36
]&
sel
[36
]);
assi
gnse
l[3
8]
=c0
[37
]|
(c1
[37
]&
sel
[37
]);
assi
gnse
l[3
9]
=c0
[38
]|
(c1
[38
]&
sel
[38
]);
assi
gnse
l[4
0]
=c0
[39
]|
(c1
[39
]&
sel
[39
]);
assi
gnse
l[4
1]
=c0
[40
]|
(c1
[40
]&
sel
[40
]);
assi
gnse
l[4
2]
=c0
[41
]|
(c1
[41
]&
sel
[41
]);
assi
gnse
l[4
3]
=c0
[42
]|
(c1
[42
]&
sel
[42
]);
assi
gnse
l[4
4]
=c0
[43
]|
(c1
[43
]&
sel
[43
]);
assi
gnse
l[4
5]
=c0
[44
]|
(c1
[44
]&
sel
[44
]);
assi
gnse
l[4
6]
=c0
[45
]|
(c1
[45
]&
sel
[45
]);
assi
gnse
l[4
7]
=c0
[46
]|
(c1
[46
]&
sel
[46
]);
assi
gnse
l[4
8]
=c0
[47
]|
(c1
[47
]&
sel
[47
]);
assi
gnse
l[4
9]
=c0
[48
]|
(c1
[48
]&
sel
[48
]);
assi
gnse
l[5
0]
=c0
[49
]|
(c1
[49
]&
sel
[49
]);
assi
gnse
l[5
1]
=c0
[50
]|
(c1
[50
]&
sel
[50
]);
assi
gnse
l[5
2]
=c0
[51
]|
(c1
[51
]&
sel
[51
]);
assi
gnse
l[5
3]
=c0
[52
]|
(c1
[52
]&
sel
[52
]);
assi
gnse
l[5
4]
=c0
[53
]|
(c1
[53
]&
sel
[53
]);
assi
gnse
l[5
5]
=c0
[54
]|
(c1
[54
]&
sel
[54
]);
assi
gnse
l[5
6]
=c0
[55
]|
(c1
[55
]&
sel
[55
]);
173
assi
gnse
l[5
7]
=c0
[56
]|
(c1
[56
]&
sel
[56
]);
assi
gnse
l[5
8]
=c0
[57
]|
(c1
[57
]&
sel
[57
]);
assi
gnse
l[5
9]
=c0
[58
]|
(c1
[58
]&
sel
[58
]);
assi
gnse
l[6
0]
=c0
[59
]|
(c1
[59
]&
sel
[59
]);
assi
gnse
l[6
1]
=c0
[60
]|
(c1
[60
]&
sel
[60
]);
assi
gnse
l[6
2]
=c0
[61
]|
(c1
[61
]&
sel
[61
]);
assi
gnco
ut
=c0
[62
]|
(c1
[62
]&
sel
[62
]);
endm
odul
e