PROJETO DE UMA ARQUITETURA BASEADA NUM …‡… · Figura 4 - Classificação dos processadores....
112
Pós-Graduação em Ciência da Computação CECIL ACCETTI RESENDE DE ATAÍDE MELO PROJETO DE UMA ARQUITETURA BASEADA NUM PROCESSADOR RISC-V PARA DESENVOLVIMENTO DE APLICAÇÕES EM SOFTWARE-DEFINED RADIO Universidade Federal de Pernambuco [email protected] www.cin.ufpe.br/~posgraduacao RECIFE 2016
Transcript of PROJETO DE UMA ARQUITETURA BASEADA NUM …‡… · Figura 4 - Classificação dos processadores....
Pós-Graduação em Ciência da Computação
CECIL ACCETTI RESENDE DE ATAÍDE MELO
PROJETO DE UMA ARQUITETURA BASEADA
NUM PROCESSADOR RISC-V PARA
DESENVOLVIMENTO DE APLICAÇÕES EM
SOFTWARE-DEFINED RADIO
Universidade Federal de Pernambuco
[email protected] www.cin.ufpe.br/~posgraduacao
RECIFE
2016
Cecil Accetti Resende de Ataíde Melo
Projeto de uma Arquitetura Baseada num Processador RISC-V para Desenvolvimento
de Aplicações em Software-Defined Radio
ORIENTADORA: Profª. Edna Natividade da Silva Barros
RECIFE
2016
Este trabalho foi apresentado à Pós-Graduação em
Ciência da Computação do Centro de Informática da
Universidade Federal de Pernambuco como requisito
parcial para obtenção do grau de Mestre em Ciência da
Computação.
Catalogação na fonte
Bibliotecária Monick Raquel Silvestre da S. Portes, CRB4-1217
M528p Melo, Cecil Accetti Resende de Ataíde
Projeto de uma arquitetura baseada num processador RISC-V para desenvolvimento de aplicações em software-defined radio / Cecil Accetti Resende de Ataíde Melo. – 2016.
111 f.:il., fig., tab. Orientadora: Edna Natividade da Silva Barros. Dissertação (Mestrado) – Universidade Federal de Pernambuco. CIn,
Ciência da Computação, Recife, 2016. Inclui referências e anexo.
1. Engenharia da computação. 2. Arquitetura de computador. 3. FPGA. I. Barros, Edna Natividade da Silva (orientadora). II. Título. 621.39 CDD (23. ed.) UFPE- MEI 2017-178
Cecil Accetti Resende de Ataide Melo
Projeto de uma Arquitetura Baseada num Processador RISC-V para Desenvolvimento de Aplicações em Software-defined Radio
Dissertação de Mestrado apresentada ao
Programa de Pós-Graduação em Ciência da
Computação da Universidade Federal de
Pernambuco, como requisito parcial para a
obtenção do título de Mestre em Ciência da
Computação
Aprovado em: 26/08/2016.
BANCA EXAMINADORA
__________________________________________
Prof. Dr. Abel Guilhermino da Silva Filho
Centro de Informática / UFPE
__________________________________________
Prof. Dr. Elmar Uwe Kurt Melcher
Departamento de Sistemas e Computação / UFCG
__________________________________________
Profa. Dra. Edna Natividade da Silva Barros
Centro de Informática / UFPE (Orientadora)
Agradecimentos
Agradeço ao CNPq (na gestão do periódo democrático, anterior aos eventos de 2016)
pelo suporte financeiro.
Agradeço à Profª Edna Barros, pela confiança e apoio durante o período que se encerra
com a conclusão desta dissertação, por seu exemplo de dedicação ao trabalho e aos seus
alunos, como provocadora, incentivadora e crítica.
Aos colegas e amigos do grupo de sistemas embarcados: Rafael Macieira, Erika
Spencer, Lucas Cambuim, Dario Soares, Marcus Duarte e Camila Nunes pelas conversas,
discussões e por tornar o ambiente do antigo laboratório C-23 o melhor possível.
À equipe do LINCS-CETENE: Pyetro Ferreira, João Paulo Barbosa, Henrique
Figueirôa, Maria Silveira, Vanessa Ogg, Bruno Neves, Hugo Albuquerque, Josivan Reis e
Severino Barros, pelas contribuições dadas ao trabalho de maneira direta ou indireta e pela
convivência durante últimos dois anos.
Ao Prof. Ricardo Emmanuel de Souza, pelas oportunidades que me proporcionou,
incentivo e pela amizade. Aos professores que contribuíram com a minha formação
acadêmica, em especial aos Prof. Marcio Cornélio, Prof. Odilon Maroja e Prof. Rafael Dueire,
pelo exemplo profissional e de conduta dentro e fora da sala de aula.
Por fim, agradeço à minha família, minha mãe Rossana, meu pai Antônio Emídio e
meu irmão Angelo pela paciência.
Aos meus amigos, desculpem o transtorno.
Shanghai, Setembro de 2016
Resumo
Os sistemas de software-defined radio práticos normalmente se dividem em duas
classes: arquiteturas reconfiguráveis em FPGA que implementam os algoritmos de
processamento de digital de sinais, com granularidade alta e, as arquiteturas baseadas em
processador. Um dos problemas no projeto de arquiteturas de processamento digital de sinais
baseadas em processador é o do suporte a compiladores e linguagens de alto nível.
Arquiteturas muito especializadas, com conjuntos de instruções extensos e muitos modos de
endereçamento, dificultam a implementação de compiladores para linguagens de alto nível.
Neste trabalho buscou-se explorar a viabilidade de um conjunto de instruções emergente,
RISC-V, e uma extensão do seu conjunto de instruções para a aplicação em processamento
digital de sinais de banda base, sobretudo nas funcionalidades de modem, em aplicações de
software-defined radio. A análise das operações de um modem, para as modulações digitais
mais utilizadas, revela que as operações feitas para modulação/ demodulação envolvem
números complexos. No entanto, aritmética de complexos não é normalmente suportada pelo
hardware em arquiteturas tradicionais. Além da arquitetura proposta para o processador, com
suporte a novas instruções especializadas, os periféricos necessários para o front-end de rádio
frequência e o software de suporte foram implementados, resultando num SoC para software-
defined radio.
Palavras-chave: Software-defined radio. DSP. FPGA
Abstract
Practical software-defined radio systems are usually classified in two main
architecture classes: Reconfigurable architectures on FPGAs, that implement coarse grained
digital signal processing algorithms, or processor-based architectures. One of the issues in the
design of processor-based digital signal processing architectures is compiler and high-level
languages support. Highly specialized architectures, with extensive instruction sets (ISA) and
addressing modes turn high-level languages compiler design a complex task. In this work we
explore the viability to extend the emerging RISC-V instruction set for baseband processing
applications for software-defined radio, especially for modem applications. The analysis of
modem functions, for the most used digital modulation schemes, reveals that the
modulation/demodulation tasks involve complex number operations. Complex number
arithmetic, however, is not supported on traditional architectures. The proposed platform
includes a 3-stage pipelined processor with new specialized instructions, as well as the
peripherals needed to the radio-frequency front-end and supporting software, resulting on a
system-on-a-chip for software-defined radio applications. software-defined radio.
Keywords: Software-defined radio. DSP. FPGA
Lista de Figuras
Figura 1 - Espectro eletromagnético, nas frequências de RF ................................................... 21
Figura 2- Diagrama de um rádio digital ................................................................................... 23
Figura 3 - Exemplos de diagramas de constelação. a) Modulação BPSK. b) Modulação QPSK
ou 4-QAM. c) Modulação 16-QAM ......................................................................................... 25
Figura 4 - Classificação dos processadores. ............................................................................. 26
Figura 5 - Arquitetura de um FPGA. Extraído de (Tocci, Widmer e Moss, 2007) .................. 28
Figura 6 - Arquitetura SIMT (Tell, Nilsson e Liu, 2005b) ....................................................... 31
Figura 7 - Arquitetura SODA(Lee, Chakrabarti e Mudge, 2010) ............................................ 32
Figura 8 - Arquitetura GOLD-X(Ramacher et al., 2011) ......................................................... 33
Figura 9 - Arquitetura do sistema proposto por (Chen et al., 2016)......................................... 34
Figura 10 - Fluxograma da metodologia de projeto utilizada .................................................. 36
Figura 11- Diagrama de blocos da arquitetura do sistema proposta......................................... 39
Figura 12 - Registradores de propósito geral e rótulos utilizados pelo compilador ................. 44
Figura 13 - Formatos das Instruções RISC-V (Waterman et al., 2014) ................................... 44
Figura 14 - Listagem das Instruções RV32IM implementadas. ............................................... 46
Figura 15 - Divisão de tarefas entre processador de banda base e processador de aplicação .. 47
Figura 16 - Representação de um número complexo da forma A = a +jb em uma palavra de 32
bits ............................................................................................................................................ 49
Figura 17 - a)Trecho de código C para multiplicação de números complexos, b) Código
assembler da multiplicação, c) Instrução equivalente, cmul ................................................... 49
Figura 18 - a)Trecho de código C para MAC de números complexos, b) Código assembler, c)
Instrução equivalente, cmac ..................................................................................................... 50
Figura 19 -Fluxograma do algoritmo Rijndael, ou AES (Ul Haq et al., 2011). Fluxograma
para encriptação à esquerda, e para decriptação, à direita. ....................................................... 51
Figura 20 - Procedimento xtime() e multiplicação em GF(28) (Daemen e Rijmen, 2002) ...... 51
Figura 21 - Procedimento Multiply() ....................................................................................... 52
Figura 22 - Diagrama da microarquitetura do processador ...................................................... 54
Figura 23 - Estrutura do Banco de Registradores ..................................................................... 56
Figura 24 - Diagrama esquemático da ALU ............................................................................. 58
Figura 25 Diagrama de blocos da CALU ................................................................................. 59
Figura 26 - Diagrama esquemático da unidade CMAC ........................................................... 60
Figura 27 - Caminho de controle do processador ..................................................................... 61
Figura 28 - Estágios do pipeline ............................................................................................... 64
Figura 29 - Espaço de endereçamento de memória .................................................................. 65
Figura 30 - Diagrama de Blocos da plataforma proposta ......................................................... 66
Figura 31 - Diagrama do barramento WISHBONE genérico, listando os sinais de controle, as
linhas de dados e de endereço (OpenCores, 2010) ................................................................... 68
Figura 32 - Diagrama dos sinais WISHBONE durante leitura (OpenCores, 2010) ................. 69
Figura 33 - Diagrama dos sinais WISHBONE durante escrita (OpenCores, 2010) ................. 69
Figura 34 - Diagrama de blocos do Controlador WISHBONE Master .................................... 70
Figura 35 - Diagrama Esquemático do módulo GPIO ............................................................. 72
Figura 36 - Diagrama esquemático do módulo wshbn_timer................................................... 73
Figura 37 - Módulo wshbn_uart ............................................................................................... 74
Figura 38 - Diagrama esquemático do módulo wshbn_ssp ...................................................... 76
Figura 39 - Diagrama Esquemático do módulo wshbn_lo ....................................................... 77
Figura 40 - Diagrama RTL do LSFR........................................................................................ 78
Figura 41 - Diagrama do modulo wshbn_duc .......................................................................... 79
Figura 42 - Resposta em frequência de um filtro CIC (Altera, 2007) ...................................... 79
Figura 43 - Diagrama esquemático do filtro CIC. a)Interpolador e b) Decimador .................. 80
Figura 44 - Diagrama do modulo wshbn_duc .......................................................................... 81
Figura 45 - Placa do front-end sobre o kit DE-0 ...................................................................... 85
Figura 46 - Amostragem dos símbolos ..................................................................................... 86
Figura 47 - Estrutura das tarefas no RIOS-modificado ............................................................ 87
Figura 48 - Tarefas no escalonador, para o caminho de transmissão de um modem ............... 87
Figura 49 - Escalonamento das três tarefas para transmissão num modem simples ................ 88
Figura 50- Trecho de código assembler da rotina de testes para a instrução add ..................... 90
Figura 51 - Captura de tela do osciloscópio durante execução do Dhrystone .......................... 92
Figura 52 - Espectro do sinal modulado em BPSK .................................................................. 95
Lista de Tabelas
Tabela 1- O Modelo OSI .......................................................................................................... 20
Tabela 2- Comparativo entre os Trabalhos Relacionados ........................................................ 35
Tabela 3 - Instruções RV32XOolong ....................................................................................... 48
Tabela 4 - Mapa de Registradores do módulo GPIO................................................................ 71
Tabela 5 - Mapa de Registradores do módulo wshbn_timer .................................................... 73
Tabela 6 - Registradores do modulo UART ............................................................................. 75
Tabela 7 - Registradores do Módulo wshbn_ssp ...................................................................... 76
Tabela 8 - Registradores do módulo wshbn_lo ........................................................................ 81
Tabela 9 - Registradores dos módulos wshbn_duc e wshbn_ddc ............................................ 81
Tabela 10 - Resultados de Síntese EP2C5T144C8 ................................................................... 83
Tabela 11 - Resultados de Síntese EP3C25Q240C8 ................................................................ 84
Tabela 12 - Resultados da Implementação do RIOS- modificado ........................................... 88
Tabela 13 - Resultados da execução das aplicações do TI embedded benchmark suite .......... 91
Tabela 14 - Comparativo da execução do Dhrystone ............................................................... 92
Tabela 15 - Resultados da execução de aplicações do MiBench ............................................. 93
Tabela 16 - Resultados da execução do filtro FIR de (Goh, 2006) .......................................... 94
Tabela 17 - Execução do modulador complexo (BPSK, 4QAM, 16QAM) ............................. 94
Tabela 18 - Execução do AES-128, em ciclos de clock, para uma entrada de 64 bytes .......... 95
Lista de Acrônimos
AM Amplitude Modulation
ASIC Application Specifc Integrated Circuit
ASIP Application Specifc Instruction Set Processor
BPSK Binary Phase-Shift Keying
CI Circuito Integrado
CPU Central Processor Unit
DSP Digital Signal Processor
FIFO First in, First Out
FM Frequency Modulation
FPGA Field Gate Programmable Array
GCC GNU C Compiler
GNU GNU‟s Not Unix
GPP General Purpose Processor
GPS Global Positioning System
GSM Global System for Mobile Communications
ISA Instruction Set Architecture
LUT Look-up table
MAC Multiply-accumulate
MSPS Million (Mega) samples per second
PSK Phase-Shift Keying
QAM Quadrature Modulation
RAM Random-Access Memory
RF Radio Frequência
RISC Reduced Instruction Set Computer
RTOS Real Time Operating System
SDR Software-defined Radio
SFDR Spurious-Free Dynamic Range
SoC System on a Chip
SRAM Static Random-Access Memory
„
Sumário
1. Introdução ........................................................................................................... 14
1.1. Escopo do trabalho ................................................................................................. 17
1.2. Organização da Dissertação ................................................................................... 18
2. Conceitos Básicos ............................................................................................. 19
2.1. Introdução............................................................................................................... 19
2.2. Software-defined radio ........................................................................................... 19
2.3. Processamento de banda base ................................................................................ 22
2.4. Processadores e Sistemas ....................................................................................... 25
2.5. FPGAs .................................................................................................................... 27
3. Trabalhos Relacionados .................................................................................. 30
3.1. Introdução............................................................................................................... 30
3.2. Arquiteturas baseadas em processador ................................................................... 30
3.3. Discussão ................................................................................................................ 34
4. Visão Geral do Projeto ..................................................................................... 36
4.1. Introdução............................................................................................................... 36
4.2. Análise dos requisitos............................................................................................. 37
4.3. Planejamento da arquitetura do processador .......................................................... 37
4.4. Projeto RTL ............................................................................................................ 37
4.5. Benchmarking ........................................................................................................ 38
4.6. Profiling das Aplicações......................................................................................... 38
4.7. Integração do processador e projeto da plataforma ................................................ 39
5. Projeto do Conjunto de Instruções ............................................................... 41
5.1. Introdução............................................................................................................... 41
5.2. O conjunto de instruções RISC-V .......................................................................... 42
5.2.1. Modelo de programação........................................................................................ 43
5.2.2. Formatos de Instrução ........................................................................................... 44
5.2.3. Instruções RV32IM ................................................................................................ 45
5.3. Profiling das aplicações alvo .................................................................................. 45
5.3.1. Processamento de banda base ............................................................................... 47
5.4. Instruções de aplicação específica – Extensão Oolong .......................................... 47
5.4.1. Instruções de aritmética complexa ........................................................................ 48
5.4.2. AES ........................................................................................................................ 50
5.5. Conclusão ............................................................................................................... 52
6. Microarquitetura ................................................................................................ 53
6.1. Introdução............................................................................................................... 53
6.2. O caminho de dados ............................................................................................... 55
6.2.1. Banco de Registradores ......................................................................................... 55
6.2.2. Unidade Lógica e Aritmética ................................................................................. 56
6.2.3. Unidade de execução Oolong ................................................................................ 58
6.3. Caminho de Controle ............................................................................................. 60
6.3.1. Unidade de Busca e Previsão de Desvios .............................................................. 61
6.3.2. Decodificador de Instruções .................................................................................. 62
6.3.4. Registradores especiais e de controle .................................................................... 62
6.4. Pipeline ................................................................................................................... 63
7. Memória e Periféricos ...................................................................................... 65
7.1. Introdução............................................................................................................... 65
7.2. Memória de Inicialização ....................................................................................... 66
7.3. Memória de Programa ............................................................................................ 66
7.4. Memória de Dados ................................................................................................. 67
7.5. Controlador de Memória ........................................................................................ 67
7.6. Barramento WISHBONE ....................................................................................... 67
7.7. Periféricos............................................................................................................... 70
7.7.1. GPIO ...................................................................................................................... 71
7.7.2. TIMER.................................................................................................................... 72
7.7.3. UART ..................................................................................................................... 73
7.7.4. SSP ......................................................................................................................... 75
7.7.5. Oscilador local ...................................................................................................... 77
7.7.6. Interface de RF ...................................................................................................... 78
8. Implementação em FPGA ............................................................................... 82
8.1. Introdução............................................................................................................... 82
8.2. Implementação RTL ............................................................................................... 82
8.2.1. Cyclone II............................................................................................................... 82
8.2.2. Cyclone III ............................................................................................................. 83
8.3. Ambiente de simulação e validação ....................................................................... 84
8.4. Escalonador de tarefas ............................................................................................ 85
8.5. Sistema de Arquivos e Drivers de Periféricos ........................................................ 88
8.6. Benchmarking e Aplicações ................................................................................... 89
8.6.1. Testes de instrução ................................................................................................ 89
8.6.2. TI Embedded Benchmark Suite .............................................................................. 90
8.6.3. Dhrystone ............................................................................................................... 91
8.6.4. MiBench ................................................................................................................. 92
8.6.5. Avaliação das Instruções da Extensão Oolong ..................................................... 93
8.7. Conclusões ............................................................................................................. 95
9. Conclusões e Trabalhos Futuros ................................................................. 97
9.1. Conclusões ............................................................................................................. 97
9.2. Trabalhos Futuros ................................................................................................... 98
Referências ....................................................................................................... 100
Anexo A - listagem das instruções propostas ....................................... 105
14
1
Introdução
Com o aumento do número de protocolos e bandas de operação dos sistemas de
comunicação sem fio, software-defined radio (SDR) tem aos poucos saído da condição de
tecnologia promissora e assumido papel central no desenvolvimento dos novos padrões em
telecomunicações civis e militares e no aprimoramento dos sistemas já existentes, que não
podem ser abandonados (FORUM, 2014)
A programabilidade é o fator chave para a implementação de sistemas de rádio-
comunicação multibanda e multiprotocolo flexíveis, como definem as técnicas de SDR. Os
circuitos integrados (CI) dedicados ou ASIC (Application-specific Integrated Circuit), que
implementam processadores de aplicação única, normalmente utilizados nos sistemas de
comunicação tradicionais necessitam de circuitos específicos para cada modo de operação,
havendo pouco compartilhamento de recursos, aumentando assim a área destes CIs, o
consumo de energia e o custo de produção destes dispositivos (LIU, 2008).
A tecnologia de projeto a ser utilizada para uma determinada aplicação (se ASICs,
circuitos com componentes discretos, ou processadores programáveis) é, além de decisão do
projetista, baseando-se na sua experiência ou de sua equipe, regida também por fatores como
custo de desenvolvimento, tempo de projeto e ainda da janela de mercado do produto, que
afeta o seu preço final ao consumidor. No contexto da evolução constante dos sistemas de
comunicação atuais, em que novos padrões mais eficientes ou adequados a determinados
cenários de utilização surgem a cada ano, sobretudo ao se considerar a recente tendência da
chamada Internet-das-Coisas (IoT, Internet-of-Things), os ASICs, mesmo possuindo o menor
custo unitário em grandes volumes necessitam de grande esforço de projeto e por sua
15
característica básica de ter um algoritmo de processamento de sinal único mapeado num
circuito, dificultam ou até tornam impraticáveis a operação multibanda e multiprotocolo.
Para implementação de um sistema de comunicação multibanda e multiprotocolo
baseado em técnicas de software-defined radio, é fundamental a utilização de técnicas de
processamento digital de sinais. Historicamente, o processamento de sinais de rádio foi feito a
partir de sistemas com circuitos analógicos, como filtros, moduladores, amplificadores. Com
a introdução dos sistemas de comunicação digital, passou-se a implementar circuitos
equivalentes aos circuitos analógicos usuais, com componentes digitais, porém com mesma
estrutura, algoritmos e topologias. Mesmo baseados em componentes digitais, estes são
circuitos de aplicação única. Os processadores digitais de sinal (DSP) surgiram
comercialmente nos anos 1980, voltados à aplicações de processamento de voz e áudio. À
medida que o aumento da capacidade de integração dos dispositivos semicondutores vem
duplicando a cada dezoito meses, a chamada Lei de Moore (embora haja sinais recentes de
que este comportamento esteja se esgotando (WALDROP, 2016) ) os DSPs tiveram sua
capacidade de processamento aprimorada, estando hoje presentes na maioria dos sistemas de
comunicação, seja na transmissão de voz, como na telefonia celular, como nos links de dados
da internet, nos modems ADSL e nos pontos de acesso de redes WiFi.
Duas categorias de circuitos de processamento digital de sinais prevalecem atualmente:
os processadoresDSP de propósito geral, e os processadores com conjunto de instruções de
aplicação específica (ASIP). DSPs de propósito geral, como os TMS320C5x da Texas
Instruments e SHARC da Analog Devices, possuem instruções alto desempenho na
implementação da maioria dos algoritmos de processamento digital de sinais tradicionais,
possuem ferramentas de suporte e desenvolvimento de software além de aplicações de
referência e casos de uso. Porém, ferramentas de código aberto para programação de
processadores DSP são escassas, salvo as produzidas pela própria empresa proprietária da
arquitetura do processador. Como são processadores de propósito geral, a depender do
software que esteja sendo executado pode haver hardware ocioso, que contribui para o
consumo de energia e desperdício de área de silício, ou mesmo limitações de desempenho em
algumas aplicações, como sistemas operacionais, por exemplo. Os processadores de aplicação
específica surgem como alternativas aos processadores DSP de propósito geral, como uma
classe de processadores com conjunto de instruções (ISA) adaptado à aplicação-alvo ou à uma
classe de aplicações (LIU, 2008).
Nas aplicações de comunicação digital, as tarefas de processamento da informação
recebida ou a ser transmitida são chamadas de processamento de banda base. Um processador
16
de banda base programável é então um ASIP especializado no processamento das cadeias de
transmissão e recepção de sinais em sistemas de comunicação sem-fio (rádio), por cabos
elétricos ou de fibra óptica (modems). É este dispositivo que permite a implementação
eficiente de sistemas de software-defined radio, sobretudo no âmbito dos sistemas
embarcados. A programabilidade deste ASIP permite o reuso de suas estruturas de hardware
entre vários padrões de comunicação ou mesmo a interoperabilidade entre padrões, a critério
do projetista e da necessidade das aplicações. Entre as classes de algoritmos que podem ser
implementados por processadores de banda base estão:
Codificação/ Decodificação de áudio/voz;
Codificação de canal;
Modulação/demodulação;
Filtragem;
Sincronização de pacotes;
Estimação de canal e equalização;
Correção de erros.
Os processadores de banda base programáveis também permitem que uma mesma
plataforma de hardware seja utilizada mesmo havendo mudanças nos protocolos e padrões
utilizados, sendo este problema resolvido por meio de updates de software, sem a necessidade
de mudanças no hardware, o que contribui para a redução da obsolescência dos dispositivos e
equipamentos de comunicação. Para permitir esta evolução constante do software e dos
padrões de comunicação, é necessário que a arquitetura do processador também possa ser
melhorada, otimizada para as aplicações já existentes, mas sem perder sua a flexibilidade para
execução de novas tarefas a serem criadas e definidas.
No desenvolvimento de um ASIP duas abordagens são as mais utilizadas: desenvolver
o conjunto completo de instruções, apenas com as instruções necessárias para a classe de
aplicações desejada ou seja, através da customização completa; ou, partir de um conjunto de
instruções básico e extendê-lo com novas instruções dedicadas à esta classe de aplicações,
através de uma customização parcial(KONG et al., 2010). Em comparação com a
customização completa, a customização parcial tem vantagens claras. A utilização de uma
arquitetura base reduz o esforço de implementação das ferramentas de desenvolvimento de
software (compilador, depurador, simulador, etc.) facilitando o uso de linguagens de
programação de alto-nível, além de permitir uma possível herança de bibliotecas de software
já existentes.
17
Algumas arquiteturas de processadores de banda base programáveis tem sido
propostas, utilizando ambas as abordagens (TELL; NILSSON; LIU, 2005a)(NILSSON,
2007)(LEE; CHAKRABARTI; MUDGE, 2010)(FUJISAWA et al., 2003). Devido à sua
simplicidade, arquiteturas com conjuntos de instrução reduzidos (RISC) são as melhores
candidatas para extensão e customização. O trabalho desenvolvido por Fujisawa propõe um
processador de banda base baseado numa arquitetura RISC de projeto próprio. Essa
abordagem como todas que utilizam arquiteturas não padronizadas, entretanto, tem o
desenvolvimento de software prejudicado.
Como uma nova especificação aberta para um conjunto de instruções de propósito
geral, a arquitetura de processador RISC-V foi desenvolvida na Universidade da Califórnia
(WATERMAN et al., 2014). Em 2015 a governança da especificação foi entregue à RISC-V
Foundation, sendo a arquitetura explorada em projetos tanto na indústria como na academia,
como uma alternativa aos conjuntos de instruções proprietários. Um conjunto de instruções
aberto e padronizado facilita o desenvolvimento de novas técnicas de projeto de hardware e
software, e tem criado uma comunidade de usuários rapidamente, o que aumenta a
disponibilidade de uma base de código estável, de forma similar ao processo ocorrido com o
lançamento do kernel Linux.
Este trabalho propõe uma extensão ao conjunto de instruções RISC-V, especializado
para o processamento de banda base e aplicações de software-defined radio. O processador
ASIP baseado no processador RISC-V foi prototipado em uma plataforma voltada à
aplicações de transmissão e recepção de dados e voz nas faixas de frequências entre 100 KHz
e 45 MHz, onde se encontram a maior parte das bandas alocadas para comunicações de de
serviços públicos e de emergência, de rádio amador, da faixa do cidadão e dedicadas a
instrumentos médicos e científicos (AGÊNCIA NACIONAL DE TELECOMUNICAÇÕES,
2014). A plataforma utilizada para prototipação utiliza um FPGA da família Cyclone III da
Altera (ALTERA, 2012).
Escopo do trabalho 1.1.
O escopo desta dissertação é o projeto de um processador de aplicação especifíca, voltado
a aplicações de processamento de banda base, tendo como foco aplicações de banda estreita,
que possibilite a programação de protocolos de transmissão de voz e dados, extendendo o
conjunto de instruções (ISA) de uma arquitetura padronizada.
18
Entre os objetivos e contribuições deste trabalho, incluem-se:
Projeto e implementação de um processador baseado no conjunto de instruções
da arquitetura RISC-V, compatível com as ferramentas de software de código
aberto GNU-GCC para esta arquitetura.
Projeto de uma extensão do ISA escolhido, considerando a padronização dos
formatos de instrução da arquitetura, para otimização de aplicações de software-
defined radio.
Projeto e implementação de unidades funcionais do processador que viabilizem
as instruções propostas.
Desenvolvimento de uma plataforma de hardware e software para execução dos
testes e dos casos de uso, incluindo periféricos do processador e front-end
digital e analógico.
Somado a estes objetivos, buscou-se realizar a plataforma de demonstração mantendo-se um
custo de implementação baixo, influenciando na escolha dos componentes (FPGA, ADC,
DAC, etc.) e comparar o processador desenvolvido com outros processadores utilizados em
sistemas embarcados.
Organização da Dissertação 1.2.
Esta dissertação é dividida em 9 capítulos, incluindo os capítulos de introdução e
conclusão. No capítulo 2, são apresentados os conceitos básicos que fundamentam o projeto
de pesquisa, assim como a motivação deste trabalho.
No capítulo 3, são discutidos os trabalhos relacionados e suas contribuições para este
trabalho, e é apresentada uma análise comparativa entre as abordagens existentes.
Os capítulos 4 a 7 descrevem, respectivamente, a arquitetura proposta para uma
plataforma de hardware e software, incluindo o processador de aplicação específica proposto
e seus periféricos, voltada ao processamento de sinais em banda base para aplicações de
software-defined radio.
O software de suporte às aplicações e os resultados experimentais são discutidos no
capítulo 8. O capítulo 9 apresenta as conclusões deste trabalho, e enumera possíveis trabalhos
futuros que podem ser derivados do trabalho desta dissertação.
19
2
Conceitos Básicos
Introdução 2.1.
Tradicionalmente, os rádios tem sido projetados para o processamento de um apenas
um formato de onda específico (GRAYVER, 2010). Esta especialização permite que o
circuito do transmissor ou do receptor seja otimizado para a aplicação desejada, em custo,
tamanho e potência. Dispositivos capazes de operar em diferentes padrões e frequências
existem desde os primeiros dias das comunicações sem fio, embora isto não os torne rádios
multipadrão. Desde os rádios AM/FM mais simples, até os aparelhos de telefonia celular mais
recentes (com suporte a padrões como WiFi, Bluetooth, NFC, GPS e também telefonia
WCDMA, GSM, etc), na maioria dos casos são compostos por módulos (hardware)
separados, dedicados a cada formato de onda, ou protocolo de comunicação. A idéia de se
unificar o hardware de um dispositivo para os vários padrões que ele suporte, ou venha a
suportar, sendo o processamento de cada formato de onda feito via software é a base do que
veio a ser definido como software-defined radio. Neste capítulo tratamos da fundamentação
dos conceitos que evolvem o projeto de um sistema de software-defined radio, dos algoritmos
e do hardware necessário para sua implementação.
Software-defined radio 2.2.
A definição do Wireless Innovation Forum (FORUM, 2014) para software-defined radio
diz:
Um software-defined radio é um rádio em que algumas ou todas as funcionalidades da
camada física são definidas via software.
20
Esta definição inclui o conceito de camadas de abstração de um sistema de comunicação.
O modelo OSI (Open Systems Interconnect) para as camadas de abstração define sete
camadas (KUROSE; ROSS, 2010) listadas na Tabela 2.1.
Tabela 1- O Modelo OSI
Número Nome Função
7 Aplicação Permite acesso aos serviços da rede para os processos e usuários
6 Apresentação Converte os dados entre o formatos da aplicação e os da rede
5 Sessão Estabelece a sessão entre os processos que se comunicam na rede
4 Transporte Controla a transferência dos dados da aplicação, corrigindo erros e perdas
3 Rede Realiza o controle dos caminhos (roteamento) dos dados até o destino
2 Enlace Transfere os quadros de dados entre os nós da rede, através da camada fisica
1 Física Realiza a transmissão/recepção propriamente dita, através de um meio físico.
O modelo de camadas permite que os sistemas de comunicação sejam divididos em partes
de função semelhante, em que cada camada realiza serviços para a camada superior, através
de interfaces padronizadas. Desta forma, aplicações diferentes (Voz e SMS, por exemplo)
podem ser executadas num mesmo sistema, ou ainda, uma mesma aplicação pode suportar a
execução através de diferentes camadas de enlace ou física. Por exemplo na troca do acesso à
internet via cabo para uma conexão sem fio, as mesmas aplicações (e-mail, streaming) podem
ser executadas.
A camada física é a responsável pelo transporte de cada bit dos dados através de um meio
físico (cabo de cobre, ar, vácuo, ou cabo de fibra óptica), descrevendo as interfaces elétricas e
mecânicas do sistema com o meio. Entre as funcionalidades da camada física estão:
Codificação dos dados
Modo de transmissão (recepção)
Acesso ao meio físico
com exceção das etapas que são dependentes do meio utilizado para comunicação, a maior
parte das funcionalidades da camada física são equivalentes, independentes do meio, seja ele
um meio comportado como cabos de fibra optica ou elétricos, ou meios mais sujeitos a
interferência, como o ar ou o vácuo. Por rádio, se entende qualquer dispositivo que transmita
ou receba informação através de sinais eletromagneticos em frequências tipicamente entre 3
kHz a 300 GHz, como exemplificado na Figura 1.
21
Figura 1 - Espectro eletromagnético até 300 GHz
Software-defined radio, em outras palavras, é um transceptor de rádio em que o
comportamento pode ser alterado mudando o programa a ser executado. Entre os parâmetros
que podem ser alterados estão: frequência ou faixa de frequências de operação, modulação e
codificação dos dados (TELL, 2005). A possibilidade de mudança do formato de onda
utilizado contrasta com as características dos rádios tradicionais, implementados
completamente em hardware, e que não suportam modificação a não ser sob intervenção em
seu circuito (NILSSON, 2007).
A necessidade por rádios flexíveis, que suportem o chaveamento entre diferentes
protocolos, frequências e modos de operação surge da demanda por interoperabilidade entre
os inúmeros sistemas de comunicação atuais. Estes dispositivos também ajudam a reduzir os
custos de fabricação e projeto dos sistemas, dando ao projetista a possibilidade de desenvolver
uma plataforma de hardware única, que tem sua funcionalidade ampliada através de
modificações no software, aumentando assim a vida útil dos produtos. Para comunicações
táticas, ou militares, software-defined radio permite que diferentes órgãos e agências, que
utilizam faixas de frequências e modos de operação distintos possam, quando necessário,
realizar comunicação conjunta, por exemplo entre os diferentes níveis de polícia (militar, civil
e federal), órgãos de defesa civil (Corpo de Bombeiros, serviços de emergência municipais ou
estaduais) e entre as forças armadas (Aeronáutica, Marinha e Exército). A implementação da
camada física em software ainda, diminui a área de placa de circuito impresso dos sistemas,
ao implementar tarefas antes executadas atraves de (multiplos) circuitos integrados em tarefas
de software em um unico processador, reduzindo o custo de fabricação, tamanho e peso, que
podem ser críticos dependendo da aplicação, em especial nos sistemas embarcados.
O hardware de rádios tradicionais é limitado pelas características dos componentes utilizados,
notadamente componentes analógicos discretos ( resistores, capacitores, indutores, etc.), não
aceitando modificações de suas funcionalidades sem a modificação física de seu circuito. Isto
resulta num maior custo de projeto e produção destes dispositivos, e na necessidade de
22
módulos TX e RX específicos para a faixa de frequência de operação desejada. Com o
crescimento da demanda dos sistemas de telecomunicações, a popularização dos serviços de
telefonia e internet, e com o aumento do número de formas de onda utilizadas em um único
aparelho – GSM, 3G, GPS, 802.11, Bluetooth, etc.– o conceito de SDR surgiu como uma
forma de simplificar e reduzir os custos do hardware, deixando os detalhes da implementação
da camada física de cada protocolo a cargo do processador de propósito geral, e não de um
hardware específico.
O Wireless Inovation Forum descreve um sistema de SDR prático como (FORUM, 2014):
SDR é uma coleção de tecnologias de hardware e software onde algumas ou
todas as funções são implementadas através de software modificável
operando em tecnologias de processamento programáveis. Estes dispositivos
incluem field-programmable gate-array (FPGA), processadores digitais de
sinais, processadores de propósito geral ou processadores de aplicação
específica.
Para realização das técnicas de SDR, conversores de dados isto é, conversores analógico-
digital, e digital-analógico, com altas taxas de amostragem (> 10 MSPS) são necessários. A
escolha destes componentes é determinada por um compromisso entre consumo de potência,
largura de banda, relação sinal-ruído (SNR), spurious-free dynamic range (SFDR), e custo
destes dispositivos.
Processamento de banda base 2.3.
Um rádio digital típico é constituído por cinco módulos básicos, como mostrado na Figura
2. O processador de aplicação é normalmente um microcontrolador ou processador de
propósito geral, o qual executa os processos que geram ou consomem os dados transmitidos
ou recebidos. Essas aplicações podem variar desde as mais simples, como um terminal de voz
ou texto, até as mais sofisticadas como decodificação de video ou mesmo um sistema
operacional completo, para acesso à internet.
23
Figura 2- Diagrama de um rádio digital
O processador de banda base é o módulo responsável pelo processamento da informação,
no nível da camada física. Este módulo é comumente chamado de modem devido à sua
principal atribuição: a modulação e demodulação dos dados transmitidos e recebidos,
respectivamente.
Da Figura 2 nota-se a existência de dois caminhos básicos, as cadeias de transmissão e de
recepção. Na cadeia de transmissão, o processador de banda base codifica e modula os dados
digitais recebidos do processador de aplicação e entrega ao conversor analógico-digital
(DAC). O sinal analógico convertido, então, é modulado na frequência da onda portadora ( a
frequência em que é transmitido pelo meio físico) e amplificado, no front-end de radio-
frequência (RF). Na cadeia de recepção, o inverso ocorre. O sinal captado pela antena é
amplificado e extraído da onda portadora, passando a ser um sinal em banda base. A
digitalização do sinal é feita através do conversor analógico-digital, que a partir daí é
equalizado, sincronizado e demodulado pelo processador de banda base, que entrega os dados
recuperados pela recepção ao processador de aplicação.
2.3.1. Modulação
Sinais digitais são usualmente representados como uma cadeia de dados binários (bits),
sequências de 0 e 1. Cabe ao processador de banda base transformar a sequência de dados
original, em uma outra, mais adequada à transmissão através de um meio físico. Este meio, o
canal de comunicação, a depender de suas características, pode acrescentar ruído e distorções
que podem corromper a informação nele transmitida. Para transmitir corretamente a sequência
binária no canal, é preciso gerar uma representação desta sequência binária de maneira
adequada ao canal. Esta representação deve permitir a recuperação da sequencia original a
partir do sinal detectado pelo receptor. O processo de mapeamento de uma sequência digital
em sinais para transmissão em um canal de comunicação é chamado de modulação digital
(PROAKIS, 2001).
24
Nos processos de modulação digital, a sequência de bits é convertida numa sequência de
símbolos, com o número de bits por símbolo determinando a taxa de transmissão da
modulação. Pela natureza dos canais típicos, os sinais transmitidos são periódicos no formato
da equação 2.1, onde x(t) é um sinal variante no tempo, fc é a frequência da portadora e ( ) é
a sua fase.
( ) ( ) ( ( )) (2.1)
Os símbolos correspondem, dentro de cada tipo de modulação, a variações da amplitude x(t)
do sinal, da frequência fc e da fase ( ). O formato de modulação digital mais simples,
chamado de Amplitude Shift Keying, ou ASK, atribui valores específicos para a amplitude do
sinal, para representação de 0 e 1. Em seu caso mais básico, com x(t) = 1 para representação
do bit 1 e x(t) = 0 para representação do bit 0, esta modulação é chamada de OOK (on-off
keying). Quando os símbolos utilizados se refletem na variação da frequência fc, tem-se a
modulação FSK (Frequency shift keying). Quando a variação é dada sobre a fase ( ) ,
obtém-se a modulação PSK, ou phase shift keying.
Os esquemas de modulação analógica, AM e FM também podem ser descritos pela
equação 2.1, assim como o caso em que tanto a amplitude quanto a fase são utilizados para
representação do sinal digital, a modulação QAM (Quadrature-amplitude modulation).
O sinal S(t) da equação 2.1 é um sinal complexo, com componentes real e imaginária.
Mapeando-se os símbolos de cada modulação no plano complexo, obtém-se o diagrama de
constelação da modulação. Neste diagrama, cada símbolo é representado por um ponto no
plano complexo.
Na Figura 3 são mostrados os diagramas de constelação de três tipos de modulação: BPSK,
QPSK e 16-QAM. A modulação BPSK (binary phase shift keying) utiliza um mapeamento de
25
Figura 3 - Exemplos de diagramas de constelação. a) Modulação BPSK. b) Modulação QPSK ou
4-QAM. c) Modulação 16-QAM
um bit por símbolo. Neste esquema, os dois valores possiveis pra cada bit, 0 ou 1, são
mapeados como símbolos correspondentes aos números 1 + 0j e -1 + 0j, respectivamente.
Na modulação QPSK, Figura 3b, é utilizado um mapeamento de 2 bits / símbolo, o que
torna possível a ocorrência de quatro símbolos 00 , 01, 10 e 11, representados no plano
complexo por -1 –j, -1+j, 1 –j e 1+j, respectivamente. Na modulação 16-QAM, o mapeamento
é feito em 4 bits / por símbolo, com a ocorrência de 16 símbolos distintos. Neste formato, a
sequência 1011, por exemplo, é mapeada no símbolo complexo 1+ 3j.
Após o mapeamento das sequências de bits nos respectivos símbolos, a modulação é
completada através da multiplicação do símbolo (um número complexo) por uma onda
portadora, que também pode ser representada através de um número complexo da forma:
( ) ( ) (2.2)
.
Processadores e Sistemas 2.4.
O principal componente de qualquer sistema computacional é a unidade central de
processamento (CPU) , também chamada de processador. Desde as CPUs descartáveis,
presentes em etiquetas de RFID e que substituem os códigos de barra, até os
26
supercomputadores utilizados para pesquisa científica, o projeto de CPUs a grosso modo
segue os mesmos princípios básicos.
As CPUs em geral possuem memória para armazenamento de programas e dados, um
caminho de dados para processamento e algum dispositivo para entrada e saída de dados ou
informação, como uma tela, botões, teclado, porta de comunicação. A maneira como estas
partes se organizam, no entanto, dependem da aplicação do sistema, que implicam em
limitações de preço, custo, tamanho, e consumo de energia.
De maneira geral, os processadores se dividem em processadores de propósito geral (GPP),
como o Intel Pentium, e os processadores de aplicação específica onde se incluem os
microcontroladores e os processadores digitais de sinais (DSP).
Figura 4- . Classificação dos processadores. (uC : microcontroladores, uP: microprocessadores, ASIP:
processadores de conjunto de instrução de aplicação específica, ASIC: circuitos ntegrados de aplicação
específica)
A divisão entre cada classe de processadores, porém, é difusa. Os processadores de
propósito geral mais recentes possuem instruções de aplicação específica, assim como os
microcontroladores e DSPs passam a suportar a execução de tarefas mais genéricas, inclusive
de sistemas operacionais. A Figura 4 ilustra este continuum das classes de processadores, com
exemplos de famílias de processadores que se enquadram nestas classes.
2.4.1. Application-specific Instruction Set Processors (ASIP)
ASIPs, ou processadores de conjunto de instruções de aplicação específica, são
processadores com instruções dedicadas a uma ou a um conjunto de aplicações. Estas
instruções são projetadas normalmente para otimizar a execução de determinados algoritmos,
reduzindo os seus gargalos de desempenho, em geral dados por operações que possuem maior
custo computacional e que são críticas ao desempenho do algoritmo.
27
O projeto de um ASIP consiste em se avaliar os trade-offs entre a flexibilidade de um
processador de propósito geral, com o desempenho para a aplicação de interesse, de um
processador de aplicação específica. Como ilustrado na Figura 4, o grau de especialização do
conjunto de instruções do ASIP pode variar bastante.
De maneira geral, para se aumentar o grau de especialização de um processador três
técnicas são normalmente utilizadas (LIU, 2008): Aceleração em nível de instrução,
aceleração em nível de função e otimização da microarquitetura.
Das três técnicas, a otimização da arquitetura foi bastante utilizada nos processadores x86,
com a adição de unidades funcionais, despacho de multiplas instruções e técnicas de
exploração do paralelismo de instrução (HENNESSY; PATTERSON, 2012). Esta abordagem,
porém, é a mais custosa em termos de área de circuito integrado e consumo de energia.
A aceleração em nível de função, adiciona ao sistema coprocessadores especializados que
em conjunto com o processador executam os algoritmos da aplicação desejada. Por exemplo
um coprocessador para compressão de imagens em câmeras fotográficas, que divide com o
processador principal, processador de aplicação, partes de algoritmos de processamento
digital de sinais, ou executam os algoritmos completos. Embora essa técnica possibilite
desempenho elevado nas aplicações desejadas, ela reduz a possibilidade de reuso deste
coprocessador em outras aplicações, ainda que semelhantes.
A aceleração em nível de instrução é a que possibilita o desenvolvimento de ASIPs. Nesta
técnica, operações ou sequências de operações comuns às aplicações de interesse são
substituídas por instruções únicas. A inclusão de novas instruções especializadas pode ser
feita através de novas estruturas de computação (caminho de dados), ou com utilização das
estruturas já existentes no processador, apenas necessitando a mudança e inclusão das novas
instruções no decodificador de instruções do processador.
A tecnologia de projeto de um ASIP também é dependente de sua aplicação.
Tradicionalmente, circuitos integrados dedicados são os mais utilizados para implementação
dos ASIPs. No entanto, com a redução do custo dos FPGAs, proporcionado em parte pelos
efeitos da lei de Moore (MOORE, 1998), estes tem ganhado espaço na implementação de
ASIPs (LIU, 2015)(MORAWIEC; HINDERSCHEIT, 2012)(PODIVINSKY et al., 2015).
FPGAs 2.5.
Field-programmable gate-arrays, FPGAs, são dispositivos semicondutores de lógica
reconfigurável, projetados para serem configurados após sua fabricação. FPGAs contém
28
estruturas chamadas blocos lógicos e uma malha de interconexões programáveis, como
mostrado na figura 5. Os blocos lógicos dos FPGAs da família Cyclone II da Altera,
utilizados neste trabalho, possuem uma tabela de busca, look-up table ou LUT, que gera as
saídas lógicas para quatro variáveis (sinais) de entrada, e um registrador, além das conexões
da malha.
Figura 5 - Arquitetura de um FPGA. Extraído de (TOCCI; WIDMER; MOSS, 2007)
FPGAs são largamente utilizados para a realização de tarefas específicas, quando o número
de dispositivos a serem produzidos não justifica a produção de circuitos integrados dedicados
(ASICs, application-specific integrated circuits) ou durante as etapas de desenvolvimento e
prototipação do sistema. Recentemente, o uso de FPGAs em produtos finais tem crescido,
sobretudo em equipamentos de teste e medição (osciloscópios, geradores de funções, etc.)
devido ao seus custos, que vêm diminuindo, e à facilidade de reconfiguração dos FPGAs, que
permite o reuso de plataformas de hardware em diferentes produtos .
A configuração dos FPGAs se dá através de linguagens de descrição de hardware, HDL,
Entre as HDL mais utilizadas estão as linguagens VHDL (DEWEY, 1983), Verilog e
SystemVerilog.
VHDL surgiu através da demanda do Departamento de Defesa, DoD, dos EUA para uma
linguagem de descrição de circuitos integrados padronizada para as indústrias de defesa e
aeroespacial. Desenvolvida inicialmente com objetivo de documentação dos circuitos
29
integrados, VHDL se mostrou adequada para a simulação destes Cis, e posteriormente para o
uso em automação do projeto eletrônico, EDA (eletronic design automation). É uma
linguagem fortemente tipada e estruturada, baseada por definição do DoD na linguagem de
programação Ada. Este trabalho utilizou VHDL em todos os módulos da arquitetura
implementada no FPGA.
30
3 Trabalhos Relacionados
Introdução 3.1.
Muitas arquiteturas de suporte a software-defined radio vem sendo propostas, pela
indústria e pela academia. Duas abordagens alternativas às tradicionais arquiteturas centradas
em ASIC tem dominado: a primeira, baseada na utilização de hardware reconfigurável e a
segunda, de arquiteturas centradas em processadores (DSP ou ASIP)(RAMACHER et al.,
2011). No entanto, uma plataforma de SDR não se restringe apenas ao processador de banda
base, sendo necessário também o desenvolvimento do front-end de RF, adequado aos padrões
convencionados.
Neste capítulo são discutidos alguns trabalhos que se aproximam do objetivos do
projeto proposto nesta dissertação, que é de desenvolver não apenas o processador mas os
componentes adicionais da plataforma, incluindo parte do front-end de RF, integrado no
mesmo FPGA.
Arquiteturas baseadas em processador 3.2.
Alguns trabalhos recentes contribuíram muito na fundamentação de arquiteturas de
DSPs alternativas aos DSPs tradicionais, para execução das tarefas de processamento de
banda base.
Os trabalhos de Tell e Nilsson (TELL; NILSSON; LIU, 2005b) (NILSSON et al.,
2005) propõem uma arquitetura, chamada Single Instruction stream – Multiple Tasks, ou
SIMT, que reúne o paralismo de instrução largamente utilizado nos DSPs comerciais
tradicionais, com o paralelismo de dados, típico das aplicações multimídia, nas quais o
processamento de banda base se inclui. A arquitetura SIMT explora a natureza vetorial dos
31
programas de banda base, com um trade-off entre uma arquitetura de paralelismo de instrução
explícito (VLIW – very long instruction word) com o paralelismo de dados SIMD (single-
instruction, multiple data).
Figura 6 - Arquitetura SIMT (TELL; NILSSON; LIU, 2005b)
A arquitetura SIMT introduz as instruções de aritmética de complexos, adequadas às
aplicações de processamento de banda base, e que não são normalmente implementadas nos
DSPs usuais. Cada unidade funcional executa operações sobre vetores de dados com tamanho
arbitrário, e distribuídos em bancos de memória independentes. A execução das operações
sobre vetores pode durar muitos ciclos de clock, no entanto o controlador pode despachar
instruções seguintes para execução concorrente em outras unidades funcionais.
Embora tenha desempenho suficiente para execução de esquemas de modulação sofisticados
como OFDM, em aplicações como Digital Video Broadcasting (DVB) e WiMax, o suporte à
programação utilizando linguagens de alto nível é limitado, devido às características da
arquitetura que dificultam a implementação de compiladores.
Com objetivo de reduzir o consumo de potência em dispositivos móveis, a arquitetura
SODA (signal processing on-demand), proposta por (LEE; CHAKRABARTI; MUDGE,
2010) utiliza uma abordagem multi-core para um processador de banda base.
A arquitetura SODA é composta por um processador de controle, quatro núcleos
SIMD e uma memória comum (scratchpad) a todos os núcleos. Cada núcleo contém dois
pipelines que suportam instruções escalares, tipo RISC, e instruções sobre vetores com até 32
valores de 16 bits. A figura 7 mostra o diagrama de blocos da arquitetura.
32
Figura 7 - Arquitetura SODA(LEE; CHAKRABARTI; MUDGE, 2010)
O suporte a aplicações de propósito geral é limitado na arquitetura SODA, e inexistente na
arquitetura SIMT, por serem ambas arquiteturas muito especializadas, não sendo adequadas
para execução de tarefas dos protocolos de comunicação além da camada física.
A arquitetura X-GOLD, proposta pela Infineon Technologies (RAMACHER et al., 2011)
resolve o problema da execução de tarefas de propósito geral, com a inclusão de uma CPU
com conjunto de instruções ARM11, lado a lado com um subsistema para SDR composto por
quatro elementos de processamento (PE) para operações vetoriais SIMD. Os comandos para
cada PE são divididos em três slots: uma instrução lógica/aritmética, uma instrução de acesso
a memória e uma terceira instrução para comunicação entre os PEs. Cada PE é formado por
um núcleo RISC com 270 instruções, em um pipeline de 7 estágios, além do caminho de
dados SIMD. As aplicações alvo da arquitetura incluem: GSM, EDGE, GPRS, UMTS, HSPA,
e LTE.
33
Figura 8 - Arquitetura GOLD-X(RAMACHER et al., 2011)
Estas três abordagens representam o estado da arte dos processadores de banda base
utilizados em comunicações móveis, com algumas das técnicas propostas já tendo sido
incorporadas nos processadores de banda base para telefonia celular mais recentes. Entretanto,
as soluções descritas, assim como a arquitetura Ardberg (ANJUM et al., 2011), AnySP entre
outras, por serem voltadas às aplicações de telefonia móvel, LTE, TV digital, e redes LAN
sem-fio, não são as mais adequadas aos sistemas de comunicação que se enquadram na
categoria de internet-of-things (IoT). Estes dispositivos em geral possuem limitações de
potência, área e custo, e não demandam processamento de banda larga.
Neste contexto, o trabalho de (CHEN et al., 2016) propõe uma arquitetura de
coprocessador de banda base voltado às aplicações de IoT. A Figura 9 ilustra a arquitetura,
que conta com um microcontrolador ARM Cortex-M0+ que se comunica com o datapath de
SDR através do barramento de memória. O sistema como um todo é capaz, de executar
programas para as modulações 4-OQPSK e FSK, para Bluetooth Low Energy (BLE) com
potência inferior a 2mW, tendo sido implementado num processo CMOS de 28nm.
34
Figura 9 - Arquitetura do sistema proposto por (CHEN et al., 2016)
Discussão 3.3.
As soluções apresentadas, embora tenham alto desempenho nas aplicações para as quais
foram projetadas, foram concebidas para implementação em circuito integrado, para
utilização em produtos de eletrônica de consumo. Estes trabalhos não definem o front-end de
RF, nem os componentes adicionais do sistema, como os upconverters e downconverters que
são normalmente utilizados para modulação nas frequências utilizadas para transmissão e
recepção.
A arquitetura SIMT introduz as instruções de aritmética complexa, e o suporte do caminho
de dados do processador aos tipos de dados complexos, embora este tipo de operação possa
ser executado em apenas um ciclo, utilizando arquiteturas VLIW ou SIMD.
No desenvolvimento de aplicações em software-defined radio é comum a utilização do
framework GNU Radio (GNURADIO, 2016). Este conjunto de ferramentas de software para
processamento digital de sinais, blocos, que podem ser integrados formando um fluxo de
dados. GNU Radio permite não só a implementação de protocolos e formatos de onda já
existentes, mas também a prototipação de novos esquemas e formatos de onda. GNU Radio,
porém, exige a utilização de um processador de propósito geral, tipicamente x86, embora
existam esforços para que seja portado a outras arquiteturas que possibilitem seu uso em
sistemas embarcados (MA et al., 2014). Para emprego do GNU Radio na prototipação e
35
implementação dos sistemas, é necessário ainda um front-end de RF compatível, entre os
disponíveis no mercado (Ettus Research, 2016).
Na Tabela 2 são listadas as características principais dos trabalhos discutidos acima. Como
será discutido nos capítulos seguintes, neste trabalho buscou-se o desenvolvimento de uma
plataforma de hardware e software para aplicações de software-defined radio, baseada em
FPGA e pelas limitações naturais desta tecnologia de projeto, voltada a aplicações de
processamento de banda base em banda estreita, com foco em permitir a prototipação e o
desenvolvimento de novas aplicações e formatos de onda. A arquitetura do processador, no
entretanto é independente da tecnologia utilizada, podendo ser portada para outros
dispositivos FPGA e ou ASIC.
Neste cenário de utilização, o trabalho proposto se enquadra como viabilizador de uma
etapa intermédiária no fluxo de projeto de sistemas de comunicação, que tem o seu
desenvolvimento iniciado utilizando-se ferramentas como GNU Radio e MATLAB, de alto
nível de abstração, em seguida tem seu software portado para um sistema como o da
arquitetura proposta, e por último é implementado em sua versão final, em arquiteturas de
processadores de banda base especializados, como os discutidos anteriormente neste capítulo.
Tabela 2- Comparativo entre os Trabalhos Relacionados
(Tell,
Nilsson e
Liu, 2007)
(RAMACHE
R et al.,
2011)
(LEE;
CHAKRABART
I; MUDGE,
2010)
(CHEN et
al., 2016)
(GNURadi
o)
Aplicação DVB/
WiMax
LTE WCDMA IoT Genérico
Linguagem Assembly/C Assembly/C Assembly/C Assembly/
C
C/Python
Aritmética Complexos/
Ponto Fixo
Ponto Fixo Ponto Fixo Ponto Fixo Ponto
Flutuante
Aceleração de
Criptografia
Não Sim Não Não x86:
AES-NI
Tecnologia de
Projeto
CMOS CMOS CMOS CMOS SW + HW
adicional
Ferramentas
de software
Proprietária Proprietária Proprietária Proprietári
a
Open-
source GPL
36
4
Visão Geral do Projeto
Introdução 4.1.
Neste capítulo é apresentada a estrutura completa da plataforma de hardware e software
proposta a ser detalhada nos capítulos seguintes, bem como é discutida metodologia de
projeto utilizada para o seu desenvolvimento, baseada no fluxo de projeto descrito em (LIU,
2008). O fluxograma desta metodologia é mostrado na Figura 10.
Figura 10 - Fluxograma da metodologia de projeto utilizada Análise dos
requisitos do sistema, exploração
das aplicações
Especificação do Conjunto de
Instruções base
Planejamento da arquitetura do processador
Especificação das Instruções de
aplicação específica
Geração do modelo RTL do processador
base
Escolha e profiling das aplicações
Benchmarking
Incorporação da extensão ao
processador base
Geração do Modelo RTL das unidades funcionais de aplicação específica
Benchmarking
Geração do Assembler e compilador
Versão Final
37
Análise dos requisitos 4.2.
Na primeira fase do projeto foi feita a análise das possíveis aplicações e dos requisitos do
sistema a ser desenvolvido. Para este trabalho, foram analisadas as aplicações de software-
defined radio e os algoritmos de processamento digital de sinais mais utilizados na área, de
modo a definir para quais aplicações o sistema deverá ser especializado.
Nesta etapa foram avaliados:
A disponibilidade do HW a ser utilizado, FPGAs e outros componentes;
Divisão de tarefas entre processador, periféricos e hardware adicional;
O conjunto de algoritmos de processamento digital de sinais, específico da
aplicação alvo, a serem otimizados;
Escolha dos casos de uso do sistema e da metodologia de avaliação do
desempenho;
Dentre as arquiteturas de processador de aplicação específica discutidos no capítulo 2,
optou-se pela customização parcial de um conjunto de instruções já existente, a arquitetura
RISC-V. A customização parcial do ISA permite o reuso das ferramentas de desenvolvimento
de software, como assembler, compilador e debugger, além de permitir o acesso à base de
código já existente para a arquitetura. A arquitetura RISC-V foi escolhida por seu conjunto de
instrução RISC básico e pelo suporte existente para extensões do ISA desde sua concepção. A
partir deste conjunto de instrução base, procedeu-se com as demais etapas do fluxo de projeto.
Planejamento da arquitetura do processador 4.3.
Antes de dar início ao projeto das instruções de aplicação específica, foi necessário o
desenvolvimento da arquitetura geral do sistema e da microarquitetura do processador. O
processador e sua plataforma (memórias e periféricos) foram especificados em nível de
transações entre circuitos combinacionais e registradores (RTL), com o projeto de todas as
unidades de computação, barramentos, módulos de controle, além dos decodificadores,
multiplexadores e demultiplexadores necessários para a interface entre cada uma das
unidades, de acordo com a especificação definida na arquitetura RISC-V. Esta etapa é
detalhada no capítulo 6, com a descrição de cada módulo da microarquitetura do processador.
Projeto RTL 4.4.
O projeto e a implementação de sistemas digitais pode ser realizado utilizando-se diferentes
níveis de abstração (GAJSKI et al., 2009). O nível de abstração RTL, ou register-transfer
38
level, é um desses níveis, em que o sistema é descrito por meio da relação entre as funções
lógicas e os elementos de armazenamento (memória ou registradores). A descrição dos
sistemas normalmente é feita por meio de linguagens de descrição de hardware (HDL), como
VHDL, Verilog, SystemVerilog ou SystemC.
Nesta etapa, além da descrição em H DL do processador, também foi realizada a descrição de
sua plataforma de hardware, barramento de periféricos, e hierarquia de memórias. O código
em HDL foi então submetido ao processo de síntese, utilizando ferramentas de software
específicas para o FPGA a ser utilizado, o que viabilizou a prototipação e os testes do sistema.
Benchmarking 4.5.
Benchmarking é o processo de análise de desempenho de um processador, considerando o
hardware e o software ou ainda a qualidade dos compiladores (LIU, 2008). Os programas
utilizados nesta análise (benchmarks) geram informações como o número de ciclos
necessários para o processador realizar uma tarefa, o tamanho do código (custo de memória) e
verificam o funcionamento do processador, comparando os resultados obtidos com os
resultados esperados para um conjunto de tarefas/aplicações.
O processo de benchmarking é iterativo, como mostra a Figura 10. Com a execução dos
programas dos benchmarks são encontrados erros e detectados pontos da arquitetura que
prejudicam o desempenho do processador, que devem ser corrigidos. Este processo dura até
que os requisitos do projeto sejam cumpridos, e que o processador se comporte como
esperado para cada uma das aplicações de teste. Os benchmarks utilizados para validação do
processador e da plataforma são discutidos no capitulo 8.
Profiling das Aplicações 4.6.
O objetivo de um processador de aplicação específica, como um DSP ou no nosso caso de
um processador de banda base, é atingir o desempenho adequado ou especificado pela
aplicação, adequando os custos de projeto, de área de circuito ou de potência necessária, de
acordo com os requisitos do projeto. Para tanto é necessário o entendimento da aplicação de
forma a identificar que partes dos seus algoritmos são críticas, que afetam o desempenho e os
custos do projeto.
Profiling (LIU, 2008) é uma técnica que permite estimar os custos de execução e de
memória do código-fonte de uma aplicação. Analisando o código-fonte de um programa,
pode-se encontrar quais as funções que quando compiladas geram maior código objeto, ou de
39
máquina (análise estática), e o número de vezes que estas são chamadas durante a execução
do programa (análise dinâmica). Desta maneira, encontram-se os kernels, ou núcleos, o
conjunto de operações aritméticas mais frequentes. Os detalhes do processo de profiling
utilizado é discutido no capítulo 5, que trata do projeto do conjunto de instruções do
processador e da inclusão das novas instruções no assembler do GCC.
Integração do processador e projeto da plataforma 4.7.
Para possibilitar o desenvolvimento de aplicações em software-defined radio, é necessário
além do processador de banda base, de um front-end de RF e de periféricos que auxiliem o
processador nestas tarefas. Além do processador de banda base outros módulos fazem parte
da arquitetura do sistema, como mostrada na Figura 11.
Figura 11- Diagrama de blocos da arquitetura do sistema proposta. Processador e periféricos: UART –
Universal Asynchronous Receiver-Transmitter (porta serial), GPIO – general purpose input-output, SSP
– synchronous serial port, DUC- digital upconverter, DDC – digital downconverter, DAC I/F, digital-
analog converter interface, ADC I/F – analog-digital converter interface. ADC e DAC externos ao FPGA.
O processador, seguindo uma arquitetura Harvard, possui memórias separadas para
programa (instruções) e dados. A memória de instruções, por sua vez, é dividida fisicamente
em duas memórias independentes: memória de inicialização, ou boot, e a memória de
aplicação. A memória de boot é a responsável pelo armazenamento das rotinas de
inicialização do sistema de arquivos FAT, e carrega os programas armazenados em um cartão
40
de memória Secure Digital (SD). Os periféricos no barramento WISHBONE são mostrados na
Figura 4.2. Os periféricos incluem: Interfaces de comunicação serial síncrona (SSP) e
assíncrona (UART), duas portas de entrada e saída de 16 bits (GPIO) e interface de rádio,
formada por um up-converter no caminho de transmissão, e um down-converter, no caminho
de recepção dos sinais de rádio. A interface de rádio recebe e envia sinais aos conversores de
sinal (ADC e DAC), fora do FPGA.
41
5
Projeto do Conjunto de Instruções
Introdução 5.1.
A principal diferença entre um processador de aplicação específica (ASIP) e um
processador de propósito geral é o seu domínio de aplicação (LIU, 2008). Processadores de
propósito geral são projetados buscando prover desempenho em várias classes de aplicações,
das mais variadas áreas e complexidades. O desempenho de um GPP não necessariamente
será o melhor para todas as classes de aplicações, tendo como objetivo o melhor desempenho
na média das aplicações. Um ASIP, por outro lado, possui instruções e microarquitetura que
limitam seu uso no processamento de classes de aplicações específicas, por exemplo um
ASIC dedicado ao processamento de áudio/video, ou no caso deste trabalho, no
processamento de sinais de rádio em banda base.
No projeto de um ASIP, a escolha da arquitetura do processador é a primeira, e mais
importante etapa. Duas formas de seleção da arquitetura são possíveis: a utilização de uma
arquitetura de referência ou, a geração de uma arquitetura dedicada, com caminho de dados
customizado para a aplicação desejada.
O desenvolvimento de uma arquitetura dedicada a uma aplicação (ou a uma classe de
aplicações) passa pela partição das tarefas entre software e hardware. A escolha entre
hardware e software para uma função depende da avaliação de várias métricas como tamanho,
potência, desempenho, custo, garantia de programabilidade para vários algoritmos dentro da
classe de aplicações, bem como a flexibilidade do sistema, sendo este processo de escolha
42
conhecido como hardware/software codesign (GAJSKI; ZHU; DÖMER, 1997). Uma
arquitetura dedicada porém, pode dificultar a implementação de compiladores para linguagens
de alto nível capaz de gerar código para conjunto de instruções específico. O projeto de
compiladores, sobretudo para a linguagem C, é simplificado quando o conjunto de instruções
é formado por instruções que realizam tarefas simples, que cobrem as operações básicas para
o execução dos programas (generalidade) e quando as instruções podem acessar os mesmos
registradores e endereços de memória (ortogonalidade). Essas características são a base das
arquiteturas RISC (reduced instruction-set architecture).
A utilização de uma arquitetura de referência, com caminho de dados mais genérico,
amplia o conjunto de aplicações que podem ser executadas pelo processador, e como
consequência sua flexibilidade. Entretanto, o aumento da flexibilidade normalmente implica
em uma diminuição no desempenho do processador. Quanto mais classes de aplicações são
suportadas, a arquitetura se torna mais próxima de um GPP, ao invés de um ASIP. Uma
arquitetura de referência, entretanto, habilita o suporte a compiladores mais simples, e o
suporte à linguagens de alto-nível, que permitem o acesso a software já existente e testado.
Considerando as vantagens e desvantagens de cada abordagem, neste trabalho optou-se
pela utilização de uma arquitetura de referência, com conjunto de instruções RISC. Neste
capítulo são apresentadas as características da arquitetura escolhida, a arquitetura RISC-V,
além da discussão de seleção das aplicações-alvo e da extensão do conjunto de instruções
RISC-V para as aplicações escolhidas.
O conjunto de instruções RISC-V 5.2.
O processador desenvolvido neste projeto é um processador de um núcleo baseado na
arquitetura RISC-V (risc-five ou risc-cinco). Publicada como uma especificação de conjunto
de instruções (ISA) aberta, disponível gratuitamente para utilização na academia e indústria, a
arquitetura RISC-V é uma arquitetura de computador com conjunto de instruções reduzido
(Reduced Instruction Set Computer, RISC) com versões de 32, 64 e 128 bits, desenvolvida
inicialmente na Universidade da Califórnia – Berkeley, tendo sido disponibilizada no segundo
semestre de 2014. A RISC-V Foundation é o órgão administrativo sem fins lucrativos,
responsável pela governança da especificação, formada por membros da comunidade
desenvolvedora que inclui empresas como Hewlett-Packard, Google, IBM, Nvidia, Oracle,
BAE Systems, além de outros membros corporativos, instituições de ensino e membros
individuais.
43
O ISA RISC-V é definido com um conjunto de instruções básicas de inteiros, que deve
ser presente em todas as implementações, e uma série de extensões opcionais ao conjunto de
instruções (WATERMAN et al., 2014). O conjunto base provê as instruções necessárias para
o suporte de ferramentas de desenvolvimento de software e de sistemas operacionais – quando
em conjunto com instruções privilegiadas do modo supervisor. Além deste, os modos de
máquina, com controle total do processador, e de usuário, limitado pelo sistema operacional,
também são suportados pela especificação.
O suporte a extensões e customização é uma característica principal da arquitetura,
tendo sido esta desenvolvida para a suportar múltiplos formatos de instrução, além de definir
as regras para adição de novos grupos de instruções para aplicações específicas.
Apesar de definir a especificação do conjunto de instruções básico e das ferramentas de
software de referência, o ISA RISC-V não define a estrutura de processador, estando a
definição da organização a cargo do projetista. Esta característica possibilita o
desenvolvimento independente de uma família de processadores RISC-V projetados sob-
medida às necessidades de desempenho, custo, área e consumo energético das variadas
aplicações, todas elas tendo em comum uma base de software compatível, incluindo sistemas
operacionais de como Linux/Android.
Nesta seção apresentamos os fundamentos da arquitetura RISC-V, como definidos na
especificação da arquitetura (WATERMAN et al., 2014).
5.2.1. Modelo de programação
RISC-V é uma arquitetura load-store, ou seja, o acesso às operandos armazenados na
memória é feito através de duas instruções para transferência dos dados da memória para os
registradores de armazenamento interno do processador, de onde são utilizados pelas demais
instruções. A arquitetura define um conjunto de 31 registradores de propósito geral , x1-x3,
que armazenam valores inteiros e o registrador x0, fixo com o valor constante zero. Na
implementação deste trabalho, utilizamos instruções de 32 bits, sendo esta também a largura
de cada registrador. A Figura 12 mostra os registradores assim como seus rótulos e funções
dedicadas, como utilizadas pelo compilador GCC. Os registradores do tipo t (t1 a t6) são
utilizados para armazenamento temporário. Os do tipo a (a1 a a7) armazenam os parâmetros
das funções, e os do tipo s (s1 a s11) são utilizados para armazenamento de variáveis.
44
Figura 12 - Registradores de propósito geral e rótulos utilizados pelo compilador
Registrador Rótulo Registrador Rótulo
x0 Zero x16 a6
x1 ra (return address) x17 a7
x2 sp (stack pointer) x18 s2
x3 gp (general pointer) x19 s3
x4 tp (temp. pointer) x20 s4
x5 t0 x21 s5
x6 t1 x22 s6
x7 t2 x23 s7
x8 s0 x24 s8
x9 s1 x25 s9
x10 a0 x26 s10
x11 a1 x27 s11
x12 a2 x28 t3
x13 a3 x29 t4
x14 a4 x30 t5
x15 a5 x31 t6
5.2.2. Formatos de Instrução
O conjunto de instruções padrão da arquitetura (WATERMAN et al., 2014) define
quatro formatos de instruções básicos : R, I, S, U, mostrados na Figura 13.
Figura 13 - Formatos das Instruções RISC-V (WATERMAN et al., 2014)
45
Por ser uma arquitetura load-store, todas as instruções operam sobre valores armazenados
nos registradores. Na figura 5.2, os campos rd, rs1 e rs2 selecionam os registradores de
destino (rd) , e de origem (rs1, rs2).
5.2.3. Instruções RV32IM
O subconjunto de instruções RV32IM é o conjunto básico da arquitetura RISC-V, que
inclui as instruções de aritmética de inteiros (I) e de multiplicação e divisão (M).
A classe de instruções aritméticas é definida como sendo do tipo R, e realiza operações
registrador-registrador, que lêem os dois registradores rs1 e rs2 e escrevem o resultado no
registrador rd. As operações do tipo R são definidas através dos campos func7 e func3 em
conjunto com o opcode da classe de instruções.
Desvios incondionais (jumps) são do tipo U, com o offset de desvio em múltiplos de 2
bytes sendo armazenado no campo imm. Desvios condicionais (branches) são instruções do
tipo S. O resultado da comparação dos registradores rs1 e rs2 determina se o desvio é feito ou
não, com o offset do desvio sendo armazenado no campo imm.
As instruções de acesso a memória são definidas como do tipo I ou S, para as instruções de
leitura ou de escrita, respectivamente. Na Figura 14 são listadas as instruções do subconjunto
RV32IM implementadas na versão do processador deste trabalho, com os campos de cada
instrução,o mnemônico da instrução em linguagem assembly e a operação realizada.
Profiling das aplicações alvo 5.3.
A escolha de um conjunto de instruções base discutida na seção anterior permite a
exploração dos algoritmos e funções do processamento de sinais de radio em banda base a
serem otimizados . Antes de se decidir que novas instruções serão introduzidas na arquitetura,
é preciso determinar a que nicho de aplicações o processador deverá ser dedicado.
Os primeiros SoC para processamento digital em banda base, notadamente o SoC Calypso,
de fabricação da Texas Instruments (TEXAS, 2000), e voltado para aplicações em terminais
móveis GSM, eram sistemas híbridos com dois núcleos independentes: um processador
(microcontrolador) da família ARM7TDMI, para as tarefas de controle e interface com
usuário (teclado, tela) e um DSP da família TMS320C5xx, para as tarefas de processamento
de sinal do protocolo GSM em banda base.
Processadores digitais de sinal tradicionais, como os TMS320 (TEXAS, 1997) ou SHARC
(ANALOG, 2016) possuem um grande número de instruções de processamento de sinais, mas
46
são limitados para aplicações que não demandam processamento intensivo ou que dependem
de eventos assíncronos, como interface de usuário, manipulação de strings de caracteres,
comunicação em protocolos lentos como serial RS-232, e sistemas operacionais de tempo
real.
Figura 14 - Listagem das Instruções RV32IM implementadas.
47
5.3.1. Processamento de banda base
Como discutido no capítulo 2, processamento de banda base envolve os algoritmos de
processamento digital de sinais utilizados nas tarefas relacionadas à camada física dos
protocolos de comunicação. Considerando os algoritmos de processamento de banda base na
etapa do modem (modulação-demodulação), percebe-se que eles operam com dados na forma
de números complexos: as técnicas mais utilizadas para modulação e demodulação utilizam
componentes em fase (I) e em quadratura (Q). Ao considerar os algoritmos de codificação,
detecção e correção de erros, estes operam sobretudo sobre bytes (caracteres), o que também
se aplica aos algoritmos de criptografia, como o AES.
Figura 15 - Divisão de tarefas entre processador de banda base e processador de aplicação
As tarefas básicas de um modem são mostradas na Figura 15. Embora não seja uma
atribuição tradicional dos modems, devido ao aumento da demanda por comunicação sem fio
entre os dispositivos e nas redes como a internet, o suporte a determinados tipos de
criptografia tem sido integrados aos modems, o que antes era típico de modems para
comunicações táticas ou militares (MILAER, 2014).
Desta maneira, analisando-se as tarefas necessárias para implementação de um modem
básico, as seguintes propriedades são observadas: a) processamento de números complexos,
b) processamento de cadeias de caracteres (inteiros de 8 bits) e c) suporte à algoritmos de
criptografia.
Instruções de aplicação específica – Extensão Oolong 5.4.
Dentro de um cenário de uso como modem, recebendo comandos de um terminal ou via
interface serial, as seguintes tarefas foram consideradas na definição das instruções
específicas do processador proposto. Foram implementados modelos destas tarefas em
linguagem C, que serviram de base para análise do código fonte descrita nas seções seguintes.
Filtros FIR complexos
Modulação digital (PSK, QAM)
48
Transformada rápida de Fourier (FFT)
Criptografia utilizando AES.
Com a análise do código fonte em linguagem C destas tarefas, percebeu-se que elas utilizam
os mesmos kernels, que foram então implementados por meio de instruções específicas. Estas
instruções são listadas na tabela 3,que mostra os campos de cada instrução, opcode e o
mnemônico em linguagem assembly. Os detalhes de cada instrução são detalhados no Anexo
A.
Tabela 3 - Instruções RV32XOolong
5.4.1. Instruções de aritmética complexa
Seis instruções de aritmética de números complexos fazem parte do conjunto de instruções
RV32XOolong. Estas são instruções do tipo R, que operam sobre valores em números
complexos utilizando aritmética de inteiros ponto-fixo de 16 bits, para as componentes real e
imaginária. A figura 16. ilustra o formato dos dados dentro de uma palavra de 32 bits, para
estas instruções. Os 16 bits menos significativos (bits 15 a 0) são utilizados para
representação da parte real, e os 16 bits mais significativos (bits 31 a 16) para a parte
imaginária. A escolha do tamanho das palavras para as componentes real e imaginária partiu
do objetivo do projeto, em que o processador de banda base interage diretamente com
conversores digital-analógico e analógico-digital, em sua maioria com tamanho de palavra
inferior a 16 bits. Uma maior precisão do lado do processador não traria benefícios, uma vez
que esta seria perdida ao utilizar-se um conversor de precisão inferior.
Observando o trecho de código em linguagem C da Figura 17a, para a multiplicação de
dois números complexos, da forma a + jb e c + jd, nota-se que são necessárias quatro
operações de multiplicação, uma adição e uma subtração. De fato, o código em linguagem
49
Figura 16 - Representação de um número complexo da forma A = a +jb em uma palavra de 32 bits
assembler RISC-V para as duas funções mul_re (parte real da multiplicação de complexos) e
mul_im (parte imaginária da multiplicação de complexos) da Figura 17b mostra que são
necessárias além destas 6 operações, mais duas instruções de retorno de procedimento,
totalizando 8 instruções ou 8 ciclos de máquina para realização de uma única multiplicação
entre duas variáveis com valores complexos. A implementação padrão desta operação na
biblioteca complex.h do compilador GCC aumenta ainda mais o número de instruções ao
utilizar tipo estruturado de dados (struct) para armazenamento das variáveis complexas.
Ao utilizar a estrutura da Figura 16 e uma instrução específica para a multiplicação de
complexos, Figura 17c, obtém se uma redução do tempo de execução desta operação, dos 8
ciclos de clock da Figura 17a para apenas 1 ciclo, sem levar em conta possíveis otimizações
de compilação para inlining (GCC, 2016).
Figura 17 - a)Trecho de código C para multiplicação de números complexos, b) Código assembler da
multiplicação, c) Instrução equivalente, cmul
Além da multiplicação, os principais algoritmos de processamento digital de sinais
envolvem a operação de multiplicação-acumulação (MAC), descrita pela expressão
A = A + B×C.
Nesta operação, três registradores são lidos (A,B e C) e um é escrito (A). Como na operação
MAC o registrador destino é normalmente um dos registradores lidos, apenas os três
50
operandos são necessários, sendo possível sua inclusão ao ISA, sem modificações nos
formatos de instrução padrão.
Figura 18 - a)Trecho de código C para MAC de números complexos, b) Código assembler, c) Instrução
equivalente, cmac
Os códigos fonte em linguagem C e linguagem assembler RISC-V para implementação da
operação MAC complexa são mostrados nas Figuras 18a e 18b. São necessários 10 ciclos de
clock para execução das funções cmplx_mac_re e cmplx_mac_im. Ao substituir estas funções
pela instrução cmac (Figura 5.7c), obtém-se um ganho em tempo de execução de 10x.
5.4.2. AES
O algoritmo AES (Advanced Encryption Standard) foi adotado como padrão pelo National
Institute of Standards and Technology (NIST) dos Estados Unidos no ano 2001, para
utilização nos sistemas de criptografia governamentais, tendo sido desenvolvido pelos
pesquisadores belgas Joan Daemen e Vincent Rijmen (DAEMEN; RIJMEN, 2002). Desde
então tem sido utilizado comercialmente, sobretudo em dispositivos que requerem baixa
latência e alto throughput, sendo as principais aplicações em redes sem-fio 802.11 e
protocolos como SSL. AES é um algoritmo de cifra de blocos simétricos, que utiliza uma
chave secreta para encriptação dos dados. Três cifras são utilizadas, AES-128, AES-192 e
AES -256, que operam em blocos de 128 bits com chaves de 128, 192 e 256 bits,
respectivamente (DAEMEN; RIJMEN, 2002).
51
Figura 19 -Fluxograma do algoritmo Rijndael, ou AES (UL HAQ et al., 2011). Fluxograma para
encriptação à esquerda, e para decriptação, à direita.
Os fluxogramas da Figura 19 ilustram os procedimentos para encriptação e decriptação,
utilizando AES. Nos procedimentos MixColumns e InvMixColumns são operações de
multiplicação em corpos finitos GF(28). Nesta representação um byte formado por bits b7 b6
b5 b4 b3 b2 b1 b0 é tratado como um polinômio com coeficientes em {0,1}, da forma:
b7 x7 + b6 x
6 + b5 x
5 + b4 x
4 + b3 x
3 + b2 x
2 + b1 x
1 + b0 x
0
Desta maneira, por exemplo, o byte com valor hexadecimal AAh é representado pelo
polinômio
AAh → 10101010b → x7 + x
5 + x
3 + x
1.
O núcleo da multiplicação entre dois polinômios quaisquer é a multiplicação de um polinômio
pelo polinômio x, sendo esta operação denominada xtime(). A Figura 20 exemplifica o
procedimento da multiplicação entre polinômios em GF(28).
Figura 20 - Procedimento xtime() e multiplicação em GF(28) (DAEMEN; RIJMEN, 2002)
Analisando o código do AES-128, foi determinado que a operação de multiplicação de
polinômios é chamada 64 vezes para cada rodada do algoritmo, que tem 10 rodadas. Como
mostrado na Figura 21, cada chamada do procedimento Multiply(), chama a operação xtime
10 vezes. Quando compilado pelo GCC, utilizando o conjunto de otimizações de compilação
–O1, o procedimento Multiply() é implementado através de 74 instruções RISC-V padrão.
52
Figura 21 - Procedimento Multiply()
Implementando a operação xtime() como uma instrução do processador, o código
compilado do procedimento Multiply() é implementado através de 26 instruções, resultando
numa redução de código fonte de 65% e num speedup de 32% para a operação de decriptação
do AES 128. Optou-se ainda pela implementação do procedimento xtime() como instrução
para manter as características do conjunto de instruções RISC-V, de instruções para operações
simples, de execução em um ciclo.
Conclusão 5.5.
Neste capítulo foi apresentado o conjunto de instruções RISC-V e as operações a serem
implementadas nas instruções da extensão Oolong, voltada às aplicações de processamento de
banda base, em especial os casos de uso como modem, com suporte à criptografia através do
AES. A especificação completa das instruções é detalhada no Anexo A.
53
6
Microarquitetura
Introdução 6.1.
A microarquitetura de um processador é a maneira pela qual as instruções de máquina são
implementadas, considerando-se os requisitos de projeto de um computador, como custo e
desempenho (TANENBAUM; AUSTIN, 2013), incluindo as unidades funcionais principais e
suas interconexões e controle (HENNESSY; PATTERSON, 2012).
Este capítulo descreve a microarquitetura do processador proposto, que implementa a
arquitetura de conjunto de instruções básicas do RISC-V de 32 bits, RV32IM, e a extensão
proposta neste trabalho, Oolong. Seguindo as regras de nomeação definidas na especificação
da arquitetura (WATERMAN et al., 2014), a microarquitetura proposta implementa o
subconjunto de instruções RV32IMXOolong.
De maneira usual, uma microarquitetura de CPU se divide em duas partes: o caminho de
dados (datapath) e o controle. O caminho de dados é o responsável pela execução das
operações lógicas e aritméticas de uma CPU. Paralelamente, o controle é o conjunto de
estruturas que gerencia o funcionamento do caminho de dados para implementação das
instruções definidas em sua arquitetura. Na figura 22 é mostrada a microarquitetura do
processador proposto, que implementa o conjunto de instruções RV32IMXOolong. O
processador é organizado em um pipeline de três estágios, dividido entre os estágios de busca
[Type a q
uo
te from
the d
ocu
men
t or th
e sum
mary o
f
an in
teresting p
oin
t. You
can p
ositio
n th
e text bo
x
anyw
here in
the d
ocu
men
t. Use th
e Draw
ing To
ols tab
to ch
ange th
e form
atting o
f the p
ull q
uo
te te
xt bo
x.]
54
Figura 22 - Diagrama da microarquitetura do processador
55
de instrução (instruction fetch, IF), decodificação e execução (DEC/EXE) e escrita de dados
(write back, WB).
O caminho de dados 6.2.
A arquitetura RISC-V é uma arquitetura load-store, ou seja, a leitura e a escrita de
operandos armazenados na memória são feita através de duas instruções dedicadas, lw e sw,
respectivamente. Neste tipo de arquitetura, as unidades funcionais não acessam diretamente a
memória, mas registradores internos que armazenam temporariamente os seus operandos.
Desta forma, o caminho de dados da CPU proposta é composto pelas memórias de instrução e
de dados, por uma unidade lógica e aritmética (ALU) de inteiros e outra equivalente para
números complexos (CALU), e por um banco de registradores de 32 bits, responsável pelo
armazenamento interno (temporário) dos operandos (variáveis) e endereços de memória
(ponteiros). Nesta seção tratamos das unidades funcionais que compõem o caminho de dados
do processador
.
6.2.1. Banco de Registradores
O banco de registradores é uma estrutura que faz parte tanto do caminho de dados da CPU,
onde são armazenados os valores temporários de variáveis dos programas em execução,
reduzindo assim os acessos à memória de dados. O banco de registradores do da arquitetura
RISC-V é um conjunto de 32 registradores de 32 bits, sendo 31 deles de propósito geral (x1-
x31), e o registrador x0, fixado com o valor 0. O número de registradores é definido pela
arquitetura, sendo resultado de um compromisso entre área ocupada e desempenho: um
número elevado de registradores aumenta a área do circuito e por consequência seu custo e
consumo de potência; um número insuficiente de registradores resulta no aumento da
quantidade de acessos à memória (que é mais lenta que os registradores), o que pode reduzir o
desempenho dos programas.
Na microarquitetura proposta, o banco de registradores permite a leitura de três operandos
A, B e C simultâneamente, e a escrita do resultado de uma operação (instrução) D. A
princípio, a arquitetura RISC-V exige a leitura de dois operandos, apenas. A introdução das
instruções CMAC , VMAC e CRADIX2 da extensão Oolong, que realizam a operação de
acumulação, onde é necessária a leitura do conteúdo do registrador de destino rd , como
mostrado na Figura 23, fez com que a leitura de três operandos fosse exigida. Cinco bits são
necessários para selecionar um registrador dentre os 32 disponíveis. A seleção dos
56
registradores a serem lidos nas saídas A,B e C são feitas através das entradas rd_r, rs1 e rs2,
respectivamente. A seleção do registrador de destino, para escrita, é feita através da entrada
rd.
A função de cada registrador, incluindo as funções de armazenamento de ponteiros
específicos, como ponteiro de topo da pilha ou de endereço de retorno, ficam a cargo do
programador (compilador), não havendo distinção física entre nenhum registrador, com
exceção do registrador x0.
Figura 23 - Estrutura do Banco de Registradores
A Figura 23 mostra o diagrama da esquemático do banco de registradores, com 32
registradores de 32 bits. Três decodificadores fazem a escolha dos registradores a serem lidos,
através do multiplexadores nas saídas A, B e C. Como será mostrado no capítulo 8, o banco
de registradores é responsável por parte significante da área total do processador.
6.2.2. Unidade Lógica e Aritmética
A unidade central do caminho de dados é a unidade lógica e aritmética (ALU). A ALU é o
conjunto de circuitos de computação responsável pela execução das intruções aritméticas
(adição, subtração, comparação, multiplicação e divisão), de lógica booleana (OR, XOR,
AND) e manipulação de bits (deslocamentos), além de realizar os cálculos dos endereços nas
57
instruções de acesso à memória (LW,LB,LH,SW,SB,SH) e da instrução de desvio relativo à
registrador JALR.
A ALU executa as instruções RISC-V, sendo todos os seus operandos vindos do banco de
registradores ou de valores imediatos, constantes passadas pelo compilador (programador) por
meio de instruções específicas.
A Figura 24 mostra os sinais de entrada e de saída da ALU. A escolha da operação a ser
executada sobre os operandos A e B é feita através da linha de controle op, de 5 bits de
largura. As seguintes operações são executadas pela ALU:
Adição
Subtração
Deslocamento à esquerda
Deslocamento à direita (lógico e aritmético)
OR
AND
XOR
Comparação, “menor que”
Multiplicação
Divisão (Quociente e resto)
Dentre as operações da ALU, apenas a divisão necessita de mais de um ciclo de clock
para execução, tendo uma latência de 32 ciclos de clock. Durante a execução da operação de
divisão, o sinal freeze_pipe é utilizado para interromper a busca das instruções seguintes
durante os 32 ciclos de clock necessários. O algoritmo de divisão é baseado no algoritmo de
subtrações sucessivas de Euclides (EUCLID, 1956). A operação de multiplicação é feita
através dos multiplicadores disponíveis no FPGA utilizado para implementação do projeto,
objeto de discussão do capítulo seguinte.
58
Figura 24 - Diagrama esquemático da ALU
6.2.3. Unidade de execução Oolong
A unidade funcional responsável pela execução das instruções de aritmética complexa e
de polinômios GF² da extensão Oolong é formada pelos módulos CALU (complex-ALU), e
CMAC (complex multiply-accumulate) sendo esta a parte principal do caminho de dados da
arquitetura proposta neste trabalho. Embora nomeada de CALU, não são executadas
operações lógicas que envolvam números complexos como o nome sugere. O termo é utlizado
como contraponto à ALU descrita na seção anterior, que lida com números inteiros.
As operações realizadas no módulo CALU são:
Soma de números complexos
Subtração de números complexos
Conjugado complexo
Multiplicação de números complexos
Multiplicação com acumulação de números complexos
Multiplicação pelo polinômio x do espaço GF²
A estrutura do módulo CALU é mostrada na Figura 25. O sinal op_sel controla a saída
da CALU, de acordo com a opção a ser executada, através do multiplexador o_mux. Todas as
operações são realizadas em um único ciclo de clock, incluindo as multiplicações (instruções
CMAC, CMUL e PXMUL).
59
Figura 25 Diagrama de blocos da CALU
Como parte da CALU, a unidade de multiplicação-acumulação complexa (CMAC) se
destaca. Esta unidade de multiplicação-acumulação complexa (CMAC) realiza a
multiplicação e multiplicação acumulação de números complexos. Como descrito no Capítulo
2, a multiplicação de dois números complexos A e B é definida como:
( ) ( ) (6.1)
Da expressão (6.1) nota-se que, aplicando-se diretamente a definição numa abordagem
simples, um circuito dedicado a esta operação necessitaria de quatro multiplicadores e três
somadores (subtrator sendo equivalente a um somador). Multiplicadores em hardware, no
entanto, são estruturas custosas em termos de área ocupada. Em alguns FPGAs o seu número
é limitado em algumas dezenas, mesmo nas familías mais recentes, como Cyclone III e IV da
Altera. Somadores, por outro lado, ocupam menor área e são implementados através das
unidades lógicas dos FPGAs. A expressão (6.1) pode ser manipulada, porém, de forma a
reduzir o número de multiplicadores, aumentando o número de somadores, através da
identidade (6.2), separada nas componentes real e imaginária das expressões (6.3) e (6.4),
respectivamente.
( ) ( ) ( ( ) ( )) (( ( ) ( ) (6.2)
* ( ) ( )+ ( ) ( ) (6.3)
*( ) ( )+ ( ) ( ) (6.4)
60
Das expressões (6.3) e (6.4) percebe-se a ocorrência do termo a(c + d) no cálculo tanto da
parte real quanto da parte imaginária, logo esta etapa pode ser feita apenas uma vez. Com
isso, apenas três multiplicadores são necessários, com o aumento de três para seis no número
de somadores.
O diagrama esquemático da microarquitetura da unidade CMAC é mostrado na Figura 26.
Nela, são executadas as instruções CMAC e CMUL. Na instrução CMAC, o resultado da
multiplicação é somado ao valor do registrador rd, que também é o destino da operação, com
efeito de um registrador acumulador.
Figura 26 - Diagrama esquemático da unidade CMAC
Caminho de Controle 6.3.
O fluxo da execução dos programas, embora possa depender do resultado das operações
no caminho de dados, é determinado através do controle do processador. Fazem parte do
controle as unidades de busca de instrução e previsão de desvio, e o decodificador de
instruções. O controle então é o responsável pela execução das instruções na ordem correta,
de acordo com o contador de programa, pelo funcionamento adequado do caminho de dados
para cada instrução através dos sinais de controle, e pelo gerenciamento dos eventos
assíncronos, como exceções e interrupções.
A estrutura do caminho de controle é mostrada na Figura 27. A unidade de busca e
previsão de desvio acessa a memória de programa no endereço determinado pelo contador de
programa (PC) e lê o conteúdo desse endereço, que é armazenado no registrador de instrução
(IR). A cada ciclo de clock o PC é incrementado, e uma nova instrução é carregada no
61
registrador IR. O decodificador de instruções, a partir do IR, gera os sinais de controle para a
ALU, CALU, Banco de Registradores e para o acesso a memória.
Figura 27 - Caminho de controle do processador
6.3.1. Unidade de Busca e Previsão de Desvios
Na unidade de busca e previsão de desvios, as instruções são carregadas da memória
de programa e a partir do seu conteúdo, parte do comportamento do processador é
determinado, antes mesmo da decodificação da instrução. O valor seguinte do PC é
determinado, seguindo os seguintes casos:
a) PC <= PC + 4 : operação normal, instruções aritméticas e de acesso a memória;
b) PC <= offset de desvio + PC : instruções de desvio incondicional
c) PC <= offset de desvio + PC : previsão de desvio, instruções de desvio condicional
d) PC <= endereço de desvio: previsão de desvio incorreta
e) PC <= endereço de desvio: desvio incondicional indireto, instrução JALR
f) PC <= end. rotina de tratamento de exceções (A014h)
g) PC <= Registrador MEPC, retorno de exceção.
A política de previsão de desvios escolhida, considerando um pipeline curto de 3
estágios, foi de previsão de desvios estática, em que desvios com offset negativo (para trás)
são considerados como taken e os desvios com offset positivo (para a frente) são considerados
como not-taken. Embora seja uma abordagem simples, num pipeline de 3 estágios ela é
vantajosa, pois a penalidade para previsões erradas é de apenas um ciclo de clock.
62
Quando uma previsão de desvio é feita incorretamente, o erro na previsão é detectado na
etapa de decodificação de instrução. Neste caso, a unidade de busca e previsão de desvios zera
o conteúdo do registrador IR, introduzindo uma bolha ou stall no pipeline. Mais detalhes do
funcionamento do pipeline neste e em outros casos de execução são analisados na seção 6.4.
6.3.2. Decodificador de Instruções
O módulo decodificador de instruções (ID) é a parte principal do controle do processador,
pois é o responsável pela geração dos sinais de controle de todos os outros módulos do
sistema. O módulo ID recebe como parâmetros os campos de opcode e de função da instrução
armazenada no registrador IR e a partir deles controla os estágios de execução e de escrita na
memória ou no registrador destino.
Os sinais de controle se dividem em três categorias:
1) Controle do fluxo de programa
2) Controle das unidades funcionais e memória
3) Controle do caminho de dados (multiplexadores, alinhamento de dados, e solução dos
conflitos do pipeline).
O decodificador de instruções também verifica a corretude da previsão de desvios, para as
instruções de desvio condicional. Nos casos em que a decisão tomada pela unidade de busca e
previsão de desvios é incorreta, o módulo ID emite os sinais de controle que interrompem a
execução do processador e passa o valor correto do PC à unidade de busca.
Os conflitos de pipeline, eventos em que ocorrem devido à dependência de dados de
instruções anteriores são detectados pelo ID e tratados, por meio de forwarding (HENNESSY;
PATTERSON, 2012).
6.3.4. Registradores especiais e de controle
A especificação da arquitetura RISC-V define um conjunto de registradores especiais de
controle (CSR) acessiveis através das instruções de sistema, divididos entre os níveis de
privilégio: modo de máquina, supervisor, hipervisor e usuário. Dentre estes registradores
apenas um foi incluído no processador proposto neste trabalho, o registrador do modo de
máquina, MEPC.
O registrador MEPC armazena o valor atual do PC quando ocorre uma exceção
(interrupção). Este valor permanece armazenado enquanto dura a execução das rotinas de
63
tratamento de exceção. Ao fim destas rotinas, o valor de MEPC é carregado de volta ao PC,
para que o processador retome o fluxo do programa no ponto em que foi interrompido.
Três tipos de interrupção ou exceções são suportadas: A interrupção de barramento,
utilizada principalmente pelo no barramento WISHBONE, e os eventos de exceções por
overflow, underflow ou divisão por zero. Em caso de opcode inexistente, a execução do
processador é interrompida, sendo executada a instrução sbreak.
Pipeline 6.4.
Durante a execução de um programa, o processador realiza as seguintes operações, em
sequência:
Busca de instruções na memória de programa
Decodificação de instruções
Leitura de registradores ou da memória
Execução de instruções
Armazena resultados na memória ou em registradores.
Pipelining (HENNESSY; PATTERSON, 2012) é uma técnica de implementação de
processadores em que as fases da execução de múltiplas instruções é sobreposta, e exemplo de
uma linha de montagem em uma fábrica. Em um pipeline, enquanto uma instrução é
decodificada, já é feita a busca da instrução seguinte, e assim sucessivamente, entre as
operações descritas acima. Pipelines são largamente utilizados nas principais arquiteturas de
processadores, sobretudo nos processadores de arquitetura RISC, sendo sua discussão extensa
na literatura (PATTERSON; HENNESSY, 2009) (TANENBAUM, 2006). Na
microarquitetura projetada, um pipeline de três estágios foi implementado. A figura 28 ilustra
a organização do pipeline, e seus estágios de busca (IF – instruction fetch), decodificação-
execução (DEC/EX) e de escrita (WB – write back), com destaque para as etapas de execução
separadas para as instruções RV32IM e para as instruções da extensão Oolong.
64
Figura 28 - Estágios do pipeline
No estágio de busca (IF) é feita a leitura das instruções e a previsão dos desvios. No
estágio DEC/EX, a instrução é decodificada, os registradores (ou memória) são lidos e as
operações da ALU ou da unidade Oolong são executadas. Por último, no estágio WB os
resultado da execução é armazenado nos registradores, ou na memória.
A escolha por três estágios de pipeline se deu como forma de reduzir os efeitos das
dependências de dados entre instruções em execução. As dependências surgem quando a
execução de uma instrução necessita de dados de instruções anteriores, que ainda não foram
escritos no pipeline. Nos casos em que a previsão de desvios não é correta, a penalidade do
pipeline é de 2 ciclos de clock.
65
7
Memória e Periféricos
Introdução 7.1.
Neste capítulo são apresentadas as estruturas externas ao processador, responsáveis
pela entrada e saída de dados e pelo armazenamento de programas e dados. Estas estruturas
são acessadas através das duas interfaces de memória do processador como memória de
instrução ou de dados. Os periféricos são acessados através da interface de memória de dados,
com endereçamento mapeado em memória. O espaço de memória do processador é único ou
seja, embora fisicamente separados, tanto memória quanto periféricos são acessados como se
fizessem parte de uma única memória contínua. A Figura 29 mostra o espaço de
endereçamento de memória. Todos os módulos descritos neste capítulo, assim como o
processador, foram implementados na linguagem de descrição de hardware VHDL pelo autor.
Figura 29 - Espaço de endereçamento de memória
66
Figura 30 - Diagrama de Blocos da plataforma proposta
Memória de Inicialização 7.2.
Como discutido no capítulo 4, a arquitetura de memória do processador permite o
carregamento de programas armazenados em um cartão de memória do padrão SD. O
software de inicialização, chamado de bootloader, é armazenado na memória de inicialização
(Boot ROM) . Esta é uma memória somente-leitura, com 1K palavras de 32 bits (8K bytes).
O bootloader é executado durante a inicialização (power-up) do processador. O bootloader
monta o sistema de arquivos FAT e busca no cartão SD o arquivo executável desejado, no
formato executable and linkable format (ELF). A escolha do arquivo executável é
normalmente feita através de uma interface de linha de comando, via porta serial RS-232. Em
seguida, o bootloader carrega o conteúdo da área de programa do arquivo executável nas
memória de programa, e o conteúdo da área de variáveis inicializadas na memória de dados.
Ao término do carregamento do arquivo executável, o bootloader desvia a execução para as
instruções armazenadas na memória de programa.
Memória de Programa 7.3.
As aplicações, para serem executadas, devem estar armazenadas na memória de programa.
Esta é implementada como uma memória do tipo RAM, com 4K palavras de 32 bits ( 16
Kbytes) sendo seu tamanho máximo limitado pela disponibilidade de memória do FPGA
utilizado.
67
Memória de Dados 7.4.
O armazenamento das variáveis e estruturas de dados dos programas são armazenados na
memória de dados, uma memória RAM de 16Kbytes.
Controlador de Memória 7.5.
O processador RISC-V descrito no capítulo anterior possui apenas uma interface de entrada e
saída para memória de dados externa. Como na arquitetura RISC-V não existem instruções
dedicadas a entrada e saída de dados para periféricos, o acesso do processador aos
registradores dos periféricos no barramento é feito através da interface de memória.
O controlador de memória realiza o direcionamento dos dados para o barramento ou para a
memória de acordo com as faixas de endereço descritas anteriormente na Figura 29.
Barramento WISHBONE 7.6.
Os endereços de 0000h até 2000h são disponibilizados para a alocação dos registradores de
controle dos períféricos, que utilizam o barramento no padrão WISHBONE para interface
com o processador.
A arquitetura de interconexão WISHBONE é um padrão de barramento livre, open-source,
voltado à implementação de systems-on-a-chip em ASICs e FPGAs, e é mantida pela
Opencores initiative (OPENCORES, 2010). Ela melhora a portabilidade dos IP cores, através
de uma interface comum simples e flexível, com suporte a diferentes topologias de
barramento. WISHBONE define apenas o protocolo de comunicação entre os módulos, e que
permite que sinais específicos do sistema sejam incorporados. Ela suporta a transferência de
dados simples e em bloco, sem especificar as características elétricas do barramento, o que
possibilita a sua implementação nas diferentes tecnologias de fabricação de ASICs e famílias
de FPGA.
A Figura 31 mostra a estrutura básica do barramento WISHBONE, numa topologia de
mestre-escravo (master-slave).
68
Figura 31 - Diagrama do barramento WISHBONE genérico, listando os sinais de controle, as linhas de
dados e de endereço (OPENCORES, 2010)
As transações WISHBONE entre master e slave utilizam um protocolo de handshaking,
com todas as transações sendo inicializadas pelo master. A especificação define dois modos
de tráfego, padrão ou pipelined. Neste trabalho, por não haver demanda de banda excessiva
entre as aplicações e o barramento, apenas o modo padrão é suportado . As escritas e leituras
podem ser feitas no modo simples, ou em bloco, tendo sido feita a opção pela leitura/escrita
no modo simples. O funcionamento do barramento WISHBONE, para leituras e escritas no
modo clássico single read/write é mostrado nas figuras 32 e 33. Na figura 32, observa-se o
comportamento dos sinais do barramento durante uma operação de leitura, do ponto de vista
do mestre do barramento. O mestre (processador) inicia a transação habilitando a porta
STB_O e colocando um valor de endereço válido na porta ADR_O. No ciclo de clock
seguinte, o slave (periférico) responde habilitando o sinal ACK_I do mestre, e apresentando
dados a serem lidos na porta DAT_I.
69
Figura 32 - Diagrama dos sinais WISHBONE durante um ciclo de leitura (OPENCORES, 2010)
A escrita no barramento é mostrada também pelo lado do mestre, na Figura 33. Nesta
operação, o mestre habilita as portas CYC_O, STB_O e WE_O, colocando um endereço
válido na porta ADR_O e os dados a serem escritos. No ciclo de clock seguinte o slave faz a
leitura dos dados e os escreve no endereço apontado por DAT_O e responde ao mestre,
habilitando o sinal ACK_O.
Figura 33 - Diagrama dos sinais WISHBONE durante um ciclo de escrita(OPENCORES, 2010)
7.6.1. Controlador WISHBONE Master
O controlador WISHBONE Master é o responsável por traduzir os comando de escrita e
leitura da interface de memória de dados do processador para o formato do barramento
WISHBONE. Este módulo opera como único mestre do barramento, não sendo necessária
nenhuma política de arbitragem do barramento.
A Figura 34 ilustra a estrutura do módulo wshbn_master, e os sinais de entrada e saída.
Uma máquina de estados realiza o controle do módulo, traduzindo os sinais recebido pela
interface com a CPU, para o formato do barramento WISHBONE descrito nas figuras 32 e 33.
70
Figura 34 - Diagrama de blocos do Controlador WISHBONE Master
Periféricos 7.7.
Periféricos são processadores (controladores) de função única, normalmente utilizados para
interface do processador com o meio externo. Executam tarefas geralmente padronizadas, que
permitem a integração ao sistema de funcionalidades que, se fossem realizadas via software
no processador, poderiam causar perda de desempenho, requerendo muitos ciclos de
processamento, ou ainda por serem naturalmente lentas, como a leitura das teclas
pressionadas pelo usuário num teclado, por exemplo.
Os períféricos implementados na plataforma proposta dão suporte à execução das
aplicações de processamento de banda base, além de prover interfaces de entrada e saída de
dados do processador. Esta seção discute os perífericos da plataforma proposta, que incluem:
Entrada e saída de propósito geral (GPIO)
Temporizadores de 64 bits
Universal Asynchronous Receiver-Transmitter (UART)
Porta serial síncrona (SSP)
Gerador de sinal arbitrário/ Oscilador Local (LO)
Digital up-converter (DUC)
Digital downconverter (DDC)
71
7.7.1. GPIO
O módulo General-Purpose Input/Output (GPIO) permite a utilização de até 8 portas de 16
bits. Cada porta pode ser configurada individualmente como entrada ou saída, através dos
registradores PIOx_DIR, onde x é o número da porta.
O registrador PIO_x contêm os dados a ser escritos ou lidos em cada uma das portas. Se a
porta x for configurada como entrada no seu registrador PIOx_DIR, o estado da porta pode
ser lido através do registrador PIO_x. Se a porta x for configurada como saída através do
registrador PIOx_DIR, o conteúdo do registrador PIO_x determina o estado da porta.
Tabela 4 - Mapa de Registradores do módulo GPIO
Endereço Registrador Largura
00h PIO_0 16 bits
04h PIO0_DIR 8 bits
08h PIO_1 16 bits
0Ch PIO1_DIR 8 bits
10h PIO_2 16 bits
14h PIO2_DIR 8 bits
18h PIO_3 16 bits
1Ch PIO3_DIR 8 bits
20h PIO_4 16 bits
24h PIO4_DIR 8 bits
28h PIO_5 16 bits
2Ch PIO5_DIR 8 bits
30h PIO_6 16 bits
34h PIO6_DIR 8 bits
38h PIO_7 16 bits
3Ch PIO7_DIR 8 bits
O módulo GPIO é utilizado principalmente para interface externa, no controle de
dispositivos como LEDs, switches e amplificadores, e na leitura de estímulos externos como
chaves, botões, etc. O mapa de registradores da GPIO é mostrado na tabela 4. O diagrama
esquemático do módulo GPIO é mostrado na figura 35.
72
Figura 35 - Diagrama Esquemático do módulo GPIO
ADR_I[3..0]CLK_ICYC_I
DAT_I[31..0]RST_ISTB_IWE_I
wshbn_gpio
A
H
Q1
Q8
ENB
PIO7_DIRPort 7
A
H
Q1
Q8
ENB
PIO_7
pio_7
WISB
ON
E C
ON
TR
OL
A
H
Q1
Q8
ENB
PIO0_DIR A
H
Q1
Q8
ENB
PIO_0
pio_0
Port 0
...
7.7.2. TIMER
Timers (temporizadores) são dispositivos que geram sinais (pulsos) a uma taxa regular.
São amplamente utilizados em sistemas embarcados para medição de tempo, escalonamento
de tarefas ou no processamento de sinais períodicos, amostrados a uma taxa fixa (taxa de
amostragem). O diagrama esquemático do módulo wshbn_timer é mostrado na figura 36. O
módulo wshbn_timer inclui dois temporizadores, cada um com um contador de 64 bits de
largura. Quando habilitados, os temporizadores contam os ciclos de clock do sistema até que
o limite definido pelo usuário, através do registrador TMRx_CMP, é atingido. Quando o valor
do contador é igual ao do limite, o temporizador gera uma interrupção de timer para o
processador. O módulo pode utilizar os ciclos de clock da CPU ou de um sinal de clock
externo. A tabela 5. mostra o mapa de registradores do módulo wshbn_timer.
O valor a ser escrito nos registradores TMRx_CMP_HI e TMRx_CMP_LO, é função do
intervalo de tempo desejado para que ocorram as interrupções. Considerando um período de
clock TCLK , e o intervalo de tempo desejado para temporização TTMR é definido como:
x C
73
Tabela 5 - Mapa de Registradores do módulo wshbn_timer
Endereço Registrador Largura
40h TMR0_CTRL 8 bits
44h TMR0_CMP_LO 32 bits
48h TMR0_CMP_HI 32 bits
4Ch TMR1_CTRL 8 bits
50h TMR1_CMP_LO 32 bits
54h TMR1_CMP_HI 32 bits
Os 32 bits mais significativos de TMRx_CMP deve ser escritos no registrador
TMRx_CMP_HI e os 32 bits menos significativos no registrador TMRx_CMP_LO.
Figura 36 - Diagrama esquemático do módulo wshbn_timer
A
H
Q1
Q8
ENB
TMR0_CMP
A
H
Q1
Q8
ENB
Counter
Comparador
1
ADR_I[3..0]CLK_ICYC_I
DAT_I[31..0]RST_ISTB_IWE_I
TMR0
wshbn_timer
WISB
ON
E C
ON
TR
OLSCLK
A
H
Q1
Q8
ENB
TMR1_CMP
A
H
Q1
Q8
ENB
Counter
Comparador
1
TMR1
SCLK
7.7.3. UART
A UART (Universal Asynchronous Receiver/Transmitter) recebe sinal de dados serial e o
armazena como dados em paralelo (1 byte), e recebe dados em paralelo e os transmite de
forma serial (VAHID; GIVARGIS, 2002) As UARTs são implementadas como períferico em
quase todas as arquiteturas de processadores comerciais, sobretudo entre os DSPs,
microcontroladores e processadores voltados aos sistemas embarcados. A estrutura do módulo
wshbn_uart é mostrada na Figura 37. Através do barramento WISHBONE, o módulo envia
74
(recebe) bytes ao processador, que são transmitidos serialmente, bit a bit, através do pino
TXD (RXD).
Figura 37 - Módulo wshbn_uart
A
H
Q1
Q8
ENB
UART_BAUD
A
H
Q1
Q8
ENB
Baud counter
Comparador
A
H
Q1
Q8
ENB
Baud CLK
WISB
ON
E C
ON
TR
OL TX FIFO
TX Shift regTX
Controle
RX FIFO
RX Shift reg
RX
Controle
1
ADR_I[3..0]CLK_ICYC_I
DAT_I[31..0]RST_ISTB_IWE_I
Gerador de Clock
Transmissor
Receptor
wshbn_uart
O diagrama de blocos da Figura 37 divide a UART em três partes principais (listadas do topo
da figura): gerador de clock, transmissor e receptor.
O gerador de clock é responsável por gerar o sinal utilizado para sincronização entre o
transmissor e o receptor. A frequência deste sinal de clock, comumente chamada de baud
rate, determina a taxa de bits por segundo a ser utilizada na UART. O registrador
UART_BAUD armazena este valor, que deve ser configurado durante a inicialização do
módulo ou a crítério da aplicação. O gerador de clock utiliza como base o clock do sistema,
CLK_I na Figura 37. O valor a ser escrito no registrador UART_BAUD para uma
determinada baud rate B é dado por:
,
onde Tclk é o período do clock do sistema.
O transmissor é composto por uma memória FIFO (first-in, first-out) com 256 entradas,
um controlador e um registrador de deslocamento. A CPU escreve na FIFO os caracteres a
75
serem transmitidos. O controlador verifica continuamente na FIFO se há dados a serem
transmitidos. No caso positivo, o registrador de deslocamento é carregado com o byte a ser
transmitido. A cada período da baud rate B, o registrador é deslocado de um bit, sendo o bit
menos transmitido pela porta TX.
O funcionamento do receptor é análogo ao do transmissor, onde os bits recebidos através
da porta RX são armazenados em um byte no registrador de deslocamento, que é em seguida
enviado à FIFO, de onde é lido pela CPU.
A listagem dos registradores disponíveis para controle da UART e seus respectivos
endereços é dada na Tabela 6.
A operação do módulo UART é habilitada através do registrador CTRL. O acesso à
TX_FIFO e RX_FIFO é feito através do registrador TXRX. Quando lido, TXRX passa à CPU
o valor no topo da RX_FIFO. Quando escrito, TXRX repassa à TX_FIFO o byte a ser
transmitido. O registrador STATUS guarda as informações do estado das FIFO, o número de
bytes armazenados em cada uma delas, se estão cheias ou vazias.
Tabela 6 - Registradores do modulo UART
Registrador End Tipo Formato
CTRL 80h Escrita RESERVADO[7:2];baud_en;enable
TXRX 84h E/L Data[7:0]
BAUD 88h Escrita clock_div[15:0]
STATUS 8Ch Leitura 0000;txfull;txemp;rxfull;rxemp;rx_stat[7:4];
tx_stat[3:0];
7.7.4. SSP
O módulo wshbn_ssp implementa o controlador mestre do barramento de comunicação
serial síncrona serial peripheral interface (SPI), desenvolvido pela Motorola. Este módulo
permite a transferência de dados full-duplex entre o processador e dispositivos externos, como
cartão SD, memórias EEPROM, conversores de dados e CODECs de áudio, por exemplo. O
diagrama esquemático do módulo wshbn_ssp é mostrado na figura 38.
76
Figura 38 - Diagrama esquemático do módulo wshbn_ssp
A
H
Q1
Q8
ENB
SPI_BAUD
A
H
Q1
Q8
ENB
Baud counter
Comparador
A
H
Q1
Q8
ENB
Baud CLK
TX Shift regMOSI
1
ADR_I[3..0]CLK_ICYC_I
DAT_I[31..0]RST_ISTB_IWE_I
Gerador de Clock
Transceptor
wshbn_ssp
MISO
WISB
ON
E C
ON
TR
OL
SCLK
/CS
Embora a geração de clock seja semelhante à do módulo wshbn_uart, a transmissão e
recepção são feitas utilizando uma única estrutura, centrada num registrador de deslocamento.
Como é característica do padrão SPI, para cada bit transmitido pela porta MOSI (master out,
slave in) um bit é lido através da porta MISO (master in, slave out). Desta forma, transmissão
e recepção formam uma única operação e utilizam o mesmo circuito.
Os registradores do módulo wshbn_ssp são listados na Tabela 7.
Tabela 7 - Registradores do Módulo wshbn_ssp
Registrador End Tipo Formato
CTRL C0h Escrita Enable;00000;CLK_EN;CLK_POL
STATUS C4h Leitura 000000;RESERVED[1:0]
BUFFER C8h E/L Data[7:0]
SS CCh Escrita SLAVE SELECT (Reservado I2C)
BAUD D0h Escrita Data[15:0]
77
7.7.5. Oscilador local
O oscilador local é um dos periféricos de aplicação específica de RF. Nele é gerada a
portadora em banda passante ou em frequência intermediária, a ser modulada com o sinal em
banda base gerado pelo processador.
O módulo wshbn_lo utiliza para geração dos formatos de onda portadora a técnica de direct
digital synthesis (DDS). Geradores de frequência baseados em DDS são estruturas que
traduzem uma palavra digital de controle, frequency-tuning word (FTW), em um sinal de
saída na frequência desejada, por meio de um oscilador numericamente controlado, NCO,
mostrado na Figura 39. A frequência do sinal de saída, senoidal, é definida como:
Figura 39 - Diagrama Esquemático do módulo wshbn_lo
onde N é a FTW e M é a largura da FTW, em bits. Mudanças em N causam mudanças
imediatas na frequência da saída, o que torna o sistema contínuo em fase, sem a necessidade
de intervalos de estabilização, como ocorre em phase-locked loops (PLLs).
O acumulador de fase e o estágio de quantização de fase realizam a tradução da FTW em
um endereço de 10 bits, a fase do sinal, para acesso à LUT, que armazena a amplitude do
sinal. A LUT é implementada numa ROM com duas portas de leitura, o que permite a síntese
simultânea das funções seno e cosseno. Pela simetria dos sinais senoidais, apenas um quarto
de um período é armazenado na LUT, o que poupa recursos de memória do FPGA, ocupando
1024 células de memória com 12 bits de largura.
No estágio de quantização de fase ocorre o truncamento da FTW de 48 bits para o
endereço de 10 bits da LUT. Esta operação leva a efeitos não desejados, com o aparecimento
78
de sinais espúrios no espectro do sinal. Para corrigir este problema, reduzindo a amplitude dos
sinais não desejados, foi utilizada a técnica de phase dithering (GENTILE, 1999). Dithering
consiste na adição de um sinal de ruído de forma a suavizar os efeitos da quantização que
levam ao surgimento de harmônicos nas frequências superiores. Com a aplicação de dithering,
as incertezas causadas pela quantização deixam de ser periódicas, espalhando os erros de fase
ao longo do espectro do sinal, reduzindo a ocorrência de spurs. O ruído adicionado à FTW é
um número pseudo-aleatório gerado por um linear feedback shift register, LFSR. A largura B
da palavra gerada pelo LFSR é B = N – P, onde N é a largura do acumulador de fase, e P é a
largura da palavra quantizada, endereço da LUT. Para N = 48 e P = 12, como implementado,
a largura do LFSR é de 36 bits.
A estrutura do LFSR, de configuração de Fibonacci, corresponde ao polinômio p, em
aritmética mod-2:
(
Figura 40 - Diagrama RTL do LSFR
7.7.6. Interface de RF
Dois módulos compõem a interface de radio-frequência da arquitetura proposta: o digital
upconverter (DUC) / e o digital downconverter (DDC). Estes dois módulos são responsáveis
pela conversão dos sinais entre banda base e a banda de passagem, na frequência da onda
portadora, na transmissão e na recepção, respectivamente.
O diagrama de blocos do módulo wshbn_duc é mostrado na figura 41. Downconverters
analógicos normalmente são projetados utilizando componentes como mixers e filtros, para
translação do sinal modulado em banda base para a frequência de transmissão. O
downconverter digital implementado é equivalente ao modelo analógico, realizando também a
operação de interpolação do sinal digital, com aumento a taxa de amostragem utilizada para
processamento, da ordem de KSPS (kilosamples/s) para a taxa de amostragem dos
conversores digital-analógicos, da ordem de MSPS (megasamples/s).
79
A mixagem, quando feita digitalmente, se reduz à multiplicação entre dois sinais digitais:
a parte real do sinal em banda base (I) e a onda portadora, gerada pelo oscilador local,
cos[15:0].
Figura 41 - Diagrama do modulo wshbn_duc
O filtro digital interpolador Cascaded Integrator-Comb (CIC) (HOGENAUER, 1980) foi
implementado para conversão entre as taxas de amostragem de processamento e do DAC. O
filtro CIC é um filtro passa-baixas formado por três etapas: Decimação ou interpolação, um
filtro integrador e um filtro comb (com resposta ao impulso semelhante à um pente). A
resposta em frequência de um filtro CIC típico é mostrada na figura 42.
Figura 42 - Resposta em frequência de um filtro CIC (ALTERA, 2007)
A função de transferência de um filtro CIC é dada pela equação 7.1, onde R é o fator de
interpolação (decimação), D é o delay do integrador e N a ordem do filtro.
( ) ( )
( ) (7.1)
80
Figura 43 - Diagrama esquemático do filtro CIC. a)Interpolador e b) Decimador
A Figura 43 mostra a estrutura do módulo wshbn_ddc. A função do downconverter é de
extrair do sinal (demodular) de RF digitalizado pelo ADC o sinal em banda base original. A
demodulação é feita em quadratura, ou seja, são extraídos do sinal de RF as componentes em
fase (real) e em quadratura (imaginária) do sinal original. Para tanto, o sinal de RF
digitalizado é multiplicado por sinais na mesma frequência, porém defasados de 90º (seno e
cosseno). Após a multiplicação (mixagem), as componentes I e Q são filtradas e têm a sua
taxa de amostragem reduzida, da taxa de amostragem utilizada na conversão analógica-digital
pelo ADC, para a taxa de amostragem escolhida pelo usuário, de modo que seja possível o
processamento do sinal em banda base pelo processador. O filtro CIC decimador é análogo ao
filtro CIC, com os estágios de integração e comb invertidos. Enquanto no filtro interpolador a
operação é feita na ordem comb-interpolação-integrador, no filtro decimador, a operação é
feita na ordem integrador-decimação-comb, como mostrado na Figura 43.
Após a filtragem e decimação, as amostras de I e Q são armazenadas em duas memórias
FIFO, até a leitura pelo processador.
81
Figura 44 - Diagrama do modulo wshbn_duc
Os registradores de controle dos módulos wshbn_lo e wshbn_ddc/wshbn_duc são
mostrados nas tabelas 8 e 9, respectivamente.
Tabela 8 - Registradores do módulo wshbn_lo
Registrador End Tipo Formato
LO_CTRL 380h Escrita RESERVADO[7:1];enable
LO_FTW0 384h Escrita Data[15:0]
LO_FTW1 388h Escrita Data[15:0]
LO_FTW2 38Ch Escrita Data[15:0]
Tabela 9 - Registradores dos módulos wshbn_duc e wshbn_ddc
Registrador End Tipo Formato
DUC_CTRL 340h Escrita RESERVADO[7:1];enable
DUC_DATA 344h Escrita Data[31:0]
DDC_CTRL 348h Escrita RESERVADO[7:1];enable
DDC_DATA 34Ch Leitura Data[31:0]
82
8
Implementação em FPGA
Introdução 8.1.
Neste capítulo, são mostrados os resultados da síntese RTL da CPU e dos períféricos que
compõem a plataforma, assim como o software de suporte à execução das aplicações: drivers
de periféricos, bootloader / sistema de arquivos e escalonador de tarefas.
Os benchmarks utilizados para avaliação da corretude e do desempenho da arquitetura
proposta são discutidos. Dois destes benchmarks são usados para execução das tarefas de um
modem (modulação – demodulação) e de criptografia, comparando o desempenho nestas
aplicações com o uso das instruções RISC-V padrão e com a extensão do ISA Oolong.
Implementação RTL 8.2.
Os módulos que compões a arquitetura proposta para o processador e seus periféricos,
descritos anteriormente nos capítulos 6 e 7, foram implementados na linguagem VHDL. A
síntese para FPGA foi feita utilizando-se a ferramenta Quartus II 13.1 da Altera. A simulação
do processador e seus periféricos foi feita utilizando o software ModelSim, da Mentor
Graphics. A plataforma proposta foi prototipada em FPGAs das famílias Cyclone II e Cyclone
III da Altera.
8.2.1. Cyclone II
83
A implementação para Cyclone II foi feita no dispositivo EP2C5T144C8, que conta com
4800 blocos lógicos. Este foi escolhido por se tratar do menor FPGA da família Cyclone II e o
de menor custo. Nesta plataforma, os seguintes módulos foram incluídos:
Processador RISC-V RV32IM
UART
SSP
TIMER
GPIO (1 porta)
e o clock máximo atingido para o EP2C5T144C8 foi de 45 MHz. Os resultados de síntese
desta implementação são mostrados na Tabela 10.
Tabela 10 - Resultados de Síntese EP2C5T144C8
Device : EP2C5T144C8 Cyclone II FPGA
Logic
Cells
Logic
Registers
Memory
bits
DSP
Processor Core 3757 1364 0 0
Integer ALU 1211 0 0 8
Program Memory 95 44 65536 0
Data Memory 89 40 32768 0
Peripherals 697 250 1024 0
Total 4638 1698 397612
%Area 98% - 84% 30%
8.2.2. Cyclone III
A arquitetura completa, como mostrada anteriormente na Figura 30, foi prototipada em um
FPGA EP3C25Q240C8 da família Cyclone III da Altera. Os resultados de síntese desta
implementação são mostrados na Tabela 11.
Nesta plataforma, os seguintes módulos foram incluídos:
Processador RISC-V RV32IMXOolong
UART
SSP
TIMER
GPIO (2 porta)
84
Up converter (DUC)
Downconverter (DDC)
Oscilador local (LO)
Tabela 11 - Resultados de Síntese EP3C25Q240C8
Device : EP3C25Q240C8 Cyclone III FPGA
Logic
Cells
Logic
Registers
Memory
bits
DSP
Processor Core 5307 1364 0 0
Integer ALU 1211 0 0 8
CMAC+VEC INST 150 0 0 10
CALU 373 0 0 0
Program Memory 100 66 262144 0
Data Memory 98 65 131072 0
Peripherals 697 379 4096 0
Total 6396 1997 397612 18
%Area 26% - 65% 27%
Ambiente de simulação e validação 8.3.
O ambiente de simulação e validação consiste no conjunto de descrições em nível RTL dos
módulos desenvolvidos em linguagem VHDL e as aplicações de teste e benchmarks,
implementados nas linguagens C e assembly, totalizando 6300 linhas de código VHDL para o
modelo RTL e testbench, e 16 aplicações de teste/benchmarks. A avaliação do funcionamento
da implementação RTL do processador proposto foi feita em três etapas. Na primeira etapa, as
aplicações teste e benchmarks, as entradas do ambiente de testes, implementados em
linguagem C foram executados no simulador da arquitetura RISC-V spike (LEE et al., 2014a),
para obtenção de um modelo de referência. Na segunda etapa, os resultados do modelo de
referência foram comparados com os resultados da execução das aplicações na simulação da
implementação em nível RTL, no Modelsim. Por último, os resultados da execução das
aplicações no processador implementado no FPGA foram comparados com os resultados das
etapas anteriores, sendo este procedimento realizado para todas as aplicações teste e
benchmarks descritos neste capítulo.
85
Para suporte à execução dos testes em FPGA dos benchmarks para aplicações reais de
processamento de banda base, foi desenvolvida uma placa de circuito impresso com o front-
end de RF, que inclui o conversor digital-analógico AD9762, com amostragem de 125 MSPS
e o conversor analógico-digital AD9235, com amostragem de 65 MSPS. A placa
desenvolvida é mostrada montada sobre o kit de desenvolvimento da Altera DE-0, na figura
45. Para medição da qualidade dos sinais em RF gerados pela plataforma proposta, foi
utilizado um analisador de espectro Rigol DSA-815TG, conforme é mostrado na seção 8.6.5
A realização destas três etapas possibilitou o refinamento da descrição em nível RTL do
processador, com a detecção e correção de erros de implementação e de erros decorrentes do
processo de síntese para FPGA, como roteamento dos sinais de clock.
Figura 45 - Placa do front-end sobre o kit DE-0
Escalonador de tarefas 8.4.
Sistemas de processamento digital de sinais são normalmente enquadrados como sistemas
de tempo real críticos (hard real-time systems). Neste tipo de sistema, os prazos (deadlines)
para execução completa das tarefas devem ser sempre respeitados (OSHANA, 2012). Num
sistema de processamento de sinais de banda base, o período de tempo fundamental a ser
respeitado é o período entre as amostras ou seja, a taxa de amostragem.
Como discutido no capítulo 2, um sinal em banda base modulado em 4QAM utiliza uma
representação de um símbolo para cada dois bits dos dados a serem modulados, com 4
símbolos possíveis. Os símbolos são sinais senoidais que diferem entre si por sua fase. Cada
símbolo é portanto, a representação digital destas senóides, realizada por valores amostrados,
como ilustrado na figura 46.
86
Figura 46 - Amostragem dos símbolos
Para transmissão (recepção) contínua de um sinal modulado em 4QAM e 4 amostras por
símbolo, com taxa de transmissão de 8000 bits por segundo (8Kbps) por exemplo, a taxa de
amostragem TS mínima é dada por:
8000 bps (2
) → 4000
→ 4
4000
= 16000
= FS
FS = 16000 amostras / segundo, ou 16KSPS
TS = 1 / FS = 1/ 16000 = 0,0000625 = 62,5 µs
Logo, para que a transmissão seja contínua, sem interrupções nos sinais, o tempo entre as
amostras deve ser de 62,5 µs, ou seja, todo o processamento entre amostras deve ser realizado
dentro do tempo TS. Caso o sistema falhe em produzir amostras dentro deste tempo, isto irá
afetar a qualidade da transmissão, ou mesmo inviabilizá-la, com a introdução de ruído no
sinal.
Esta característica dos sistemas de processamento digital de sinais, e em especial os de
processamento de banda base tornam necessário um componente de software adicional para o
seu funcionamento: o sistema operacional de tempo real (RTOS), ou no mínimo seu
componente principal, o escalonador de tarefas.
Para execução das tarefas de processamento de banda base , respeitando os deadlines de
cada tarefa e da amostragem, foi implementado um escalonador de tarefas não-preemptivo,
baseado no trabalho de (MILLER; VAHID; GIVARGIS, 2012). Comparado com outros
RTOS de código aberto (FreeRTOS e AtomThreads), o RIOS (Riverside-Irvine Operating
System) apresenta o menor overhead de execução, tamanho de código compilado e linhas de
código C, tendo sido adaptado à execução das tarefas de banda base.
Seguindo o modelo descrito em (MILLER; VAHID; GIVARGIS, 2012), as tarefas são
definidas como um struct com os seguintes parâmetros, com adição dos parâmetros in e out:
period, o intervalo de tempo entre as execuções;
elapsedTime, tempo desde a ultima execução;
87
in, sinal de entrada da tarefa;
out, sinal de saída da tarefa;
tickFct(), ponteiro para a função da tarefa.
O escalonador utiliza o timer do processador como base de tempo. Para configuração do
timer é usado o maior divisor comum (MDC) dos períodos das tarefas. A cada vez que o valor
do timer é igual ao MDC dos períodos, o processador é interrompido, e a rotina de tratamento
de interrupção verifica se o parâmetro elapsedTime de cada tarefa é maior ou igual ao período
da tarefa. Em caso positivo, a tarefa apontada por tickFct() é executada. Caso o valor seja
menor, o MDC é adicionado a elapsedTime.
Figura 47 - Estrutura das tarefas no RIOS-modificado
Uma aplicação típica utilizando o RIOS, adaptado para processamento de sinais de banda
base pode ser visualizada como uma cadeia de tarefas, como mostrado na Figura 48. Neste
exemplo do caminho de transmissão de um modem simples, três tarefas são necessárias. A
primeira tarefa lê da entrada do sistema os bytes a serem enviados em sequência e os repassa à
segunda tarefa, que executa um algoritmo de modulação e envia o sinal a uma terceira tarefa
que realiza a interface do software com o hardware da cadeia de transmissão, através do
driver do dispositivo (wshbn_duc, descrito no capítulo 7).
Figura 48 - Tarefas no escalonador, para o caminho de transmissão de um modem simples
88
A execução das tarefas do exemplo da Figura 48 é mostrada na Figura 49. Neste exemplo,
a cada período de tempo múltiplo de TS as três tarefas T1, T2 e T3 são executadas em
sequência. Ao fim da execução de T3, o processador fica ocioso, aguardando o próximo
evento de interrupção do timer.
Figura 49 - Escalonamento das três tarefas para transmissão num modem simples
Tabela 12 - Resultados da Implementação do RIOS- modificado
Linhas de Código C Overhead (ciclos, p/ 3
tarefas)
Tamanho de código compilado
62 114 76 instruções (304 bytes)
Sistema de Arquivos e Drivers de Periféricos 8.5.
Além do escalonador de tarefas, o software básico para suporte das aplicações inclui o
sistema de arquivos FAT16 e os drivers de acesso aos periféricos do barramento
WISHBONE.
Como discutido anteriormente no capítulo 7, os aplicativos são armazenados num cartão
microSD, de onde são carregados para execução pelo bootloader. O sistema de arquivos é o
conjunto de procedimentos que permitem acessar o conteúdo do cartão de memória,
formatado em FAT16. O bootloader junto com sistema de arquivos compreende 946 linhas de
código em linguagem C, com 16 procedimentos, para inicialização do sistema de arquivos,
leitura das tabelas de alocação e dos dados dos arquivos executáveis, inicialização, leitura e
escrita do SD card, e desmontagem dos arquivos executáveis no formato ELF (Executable and
Linkable Format).
Os drivers de periféricos realizam a interface entre as aplicações e o hardware necessário,
fornecendo os procedimentos adequados ao funcionamento de cada periférico. Os seguintes
drivers e suas APIs foram implementados:
driver da UART, 217 linhas de código C, 8 procedimentos
89
driver da porta serial síncrona (protocolo SPI, usada pelo o cartão SD ) 342 linhas
de código C, 6 procedimentos
driver da interface de RF (wshbn_duc e wshbn_ddc), 50 linhas de código C, 5
procedimentos.
Benchmarking e Aplicações 8.6.
A avaliação do desempenho e validação da implementação da arquitetura proposta neste
trabalho foi feita em duas etapas. Na primeira etapa, buscou-se validar o funcionamento
do processador através de aplicações e benchmarks de processamento de inteiros:
Suite de testes de instruções RISC-V;
Suite de testes da Texas Instruments para o microcontrolador MSP430 (GOH,
2006);
Dhrystone;
MiBench (GUTHAUS et al., 2001)
o Automotive
isqrt;
o Office
String search.
Na segunda etapa, as instruções da extensão Oolong proposta foram avaliadas através das
seguintes aplicações:
Filtro FIR Complexo;
Modem BPSK;
Modem 4QAM;
AES-128.
8.6.1. Testes de instrução
O conjunto de ferramentas de deenvolvimento da arquitetura RISC-V inclui o diretório
/riscv-tools/isa onde estão presentes rotinas de testes para as instruções do conjunto de
instruções base RV32IM e demais extensões padrão.
Estas rotinas de testes avaliam a corretude da implementação do processador, buscando
encontrar erros na microarquitetura, devidos a conflitos de pipeline ou no caminho de dados
de cada instrução. A figura 50 exemplifica um destes testes, com um trecho da rotina de teste
da instrução add. Em cada procedimento uma operação com a instrução em teste é executada,
90
e seu resultado comparado com os valores esperados. Caso a comparação seja verdadeira, o
programa segue ao próximo procedimento. No caso contrário, a execução é interrompida.
Todas as 50 instruções RV32IM implementadas foram avaliadas com suas rotinas de teste,
durante o desenvolvimento, com as eventuais inconsistências sendo resolvida, até que todas as
instruções passassem pelo teste sem erros.
Figura 50- Trecho de código assembler da rotina de testes para a instrução add
8.6.2. TI Embedded Benchmark Suite
O Application Report SLAA205C da Texas Instruments (GOH, 2006) apresenta um
conjunto de aplicações para avaliação do desempenho de processadores e microcontroladores,
voltados à utilização em sistemas embarcados, comparando arquiteturas comerciais destes
dispositivos com os microcontroladores MSP430. Neste trabalho utilizou-se este conjunto de
aplicações para verificação do funcionamento do processador, para o conjunto de instruções
base RV32IM.
As seguintes aplicações são sugeridas por (GOH, 2006):
8-bit math
8-bit matrix
8-bit switch
16-bit math
16-bit matrix
16-bit switch
32-bit math
91
Matrix multiplication
Os resultados da execução destas aplicações são listados na Tabela 13.
Tabela 13 - Resultados da execução das aplicações do TI embedded benchmark suite
8-bit
math
8-bit
matrix
8-bit
switch
16-bit
math
16-bit
matrix
16-bit
switch
32-bit
math
Matrix
mult.
Tamanho de código 106 97 120 114 100 120 100 114
Ciclos p/ execução 49 864 28 57 1104 28 38 1021
Nº de instruções 44 763 27 52 976 27 38 946
CPI 1,11 1,13 1,03 1,09 1,13 1,03 1 1,08
CPI médio 1,075
8.6.3. Dhrystone
Dhrystone é um benchmark inicialmente desenvolvido por Reinhold Wecker na
linguagem Ada, para avaliar o desempenho dos processadores no tratamento de ponteiros,
estruturas de dados, arrays e strings de caracteres. Embora sua utilização como método de
avaliação de desempenho tenha sido contestada (YORK, 2002), em detrimento de
benchmarks mais recentes, como CoreMark, a avaliação de processadores com o Dhrystone
permanece como padrão de facto, entre outros motivos pela sua história, que permite a
comparação entre processadores de diferentes épocas, e sua portabilidade, existindo versões
para as várias arquiteturas de processadores, de 8, 16, 32 ou 64 bits.
A métrica utilizada é o número de execuções do benchmark em um segundo, dhrystones/s.
Para efeito de comparação, é comum comparar o número de dhrystones/s com o resultado da
execução para o VAX 11/780, um processador capaz de executar nominalmente 1 MIPS
(million instructions per second). Desta maneira, o resultado do dhrystone para um
processador qualquer é dividido por 1757 (o número de dhrystones/s do VAX 11/780),
obtendo-se assim o valor em DMIPS (Dhrystone MIPS). Como este número ainda é
dependente da frequência de clock do processador, é comum normalizar o valor obtido em
DMIPS pelo valor da frequência de clock, obtendo-se assim o resultado em DMIPS/MHz, de
modo a permitir a comparação entre processadores com diferentes clocks.
Para medição do número de Dhrystones/s no processador em execução no FPGA o
benchmark foi executado 1000 vezes, e o tempo para execução foi determinado com ajuda de
um osciloscópio Agilent DSO-1052E. Imediatamente antes da execução do benchmark, foi
realizada uma escrita no bit 0 da GPIO 0 do barramento WISHBONE, que permaneceu setado
até o fim da execução, como mostra a Figura 51.
92
Os resultados para execução do Dhrystone do processador deste trabalho são comparados
com processadores ARM similares (ARM, 2009, 2011; YORK, 2002), com pipeline de 3
estágios, e com a implementação de referência da arquitetura RISC-V, o Rocket de 5 estágios
de pipeline (LEE et al., 2014b), na Tabela 14. Os valores se referem a compilação utilizando o
conjunto de otimizações O3 do GCC, exceto quando especificado.
Figura 51 - Captura de tela do osciloscópio durante execução do Dhrystone (Agilent DSO-1052E)
Tabela 14 - Comparativo da execução do Dhrystone
DMIPS/MHz Plataforma Frequência Máxima
ARM7TDMI-S 0.9 DMIPS/MHz - <100 MHz
ARM Cortex-M0 1.02 DMIPS/MHz - <100 MHz
ARM Cortex-M1 0.8 DMIPS/MHz FPGA 100 MHz
RISC-V 32IM
Oolong –O0
0.9 DMIPS/MHz FPGA 135 MHz
RISC-V 32IM
Oolong –O1
1.36 DMIPS/MHz FPGA 135 MHz
RISC-V Rocket
(Lee et al. 2014)
1.72 DMIPS/MHz TSMC40GPLUS 1.3GHz
8.6.4. MiBench
O MiBench é uma suite de benchmarks desenvolvida pelo departamento de Engenharia
Elétrica e Ciência da Computação da Universidade de Michigan em Ann Harbor. Os
benchmarks são divididos em seis categorias de aplicações: automotiva e controle industrial,
consumo, automação de escritório (Office), redes, segurança e telecomunicações
(GUTHAUS et al., 2001). Cada benchmark é disponibilizado com seu código fonte em
linguagem C. No entanto, a maioria destes programas utilizam arquivos como entradas de
93
dados para processamento, o que limita sua execução a dispositivos que contam com sistemas
operacionais completos, com suporte a abertura e escrita de arquivos, o que não é verdade
para o processador proposto neste trabalho.
Desta forma, foram executados apenas duas aplicações que não utilizam entrada e saída
por arquivos: a aplicação isqrt, do pacote automotivo e controle industrial, e a aplicação string
search, do pacote de automação de escritório.
A aplicação isqrt executa o cálculo da raiz quadrada de um número inteiro, em aritmética
de ponto fixo, utilizando operações de deslocamento, soma e subtração, sem o uso de
multiplicadores ou divisores. A aplicação string_search é uma implementação do algoritmo de
Pratt-Boyer-Moore de busca de sequências de caracteres (BOYER; MOORE, 1977).
Tabela 15 - Resultados da execução de aplicações do MiBench
Tamanho do código
compilado
Número de
ciclos
Número de
instruções
CPI
Isqrt 127 39322 38914 1,01
String
search
322 60420 60420 1
8.6.5. Avaliação das Instruções da Extensão Oolong
Para validar a utilização das instruções de processamento de banda base propostas na
extensão Oolong do conjunto de instruções RISC-V, três aplicações básicas foram
implementadas: Filtro FIR, Modulador digital em quadratura, e o algoritmo de criptografia
AES.
Filtros são operações em processamento digital de sinais que removem características não
desejadas de um sinal. Filtros digitais são a operação mais utilizada em sistemas de DSP, e
permitem que frequências específicas do sinal sejam atenuadas, bloqueadas ou passem
livremente (OSHANA, 2012). A operação principal nos filtros FIR (finite impulse response) é
a multiplicação com acumulação, discutida na seção 5.4.
Para avaliar o desempenho das instruções de aritmética complexa cmac, cmul e cadd,
utilizou-se como base a implementação do filtro FIR disponível em (GOH, 2006). Os
resultados da execução do filtro FIR são mostrados na Tabela 16, para a implementação
original utilizando as instruções básicas RV32IM, e para a implementação que utiliza as
instruções da extensão Oolong.
Dos dados da Tabela 16 percebe-se uma redução de 51% do código compilado (memória
de programa) e de 50% no uso de memória de dados, para um filtro FIR com 17 coeficientes,
94
e uma entrada de 67 pontos, utilizando a estrutura de representação de números complexos da
Figura 5.5.
Tabela 16 - Resultados da execução do filtro FIR de (GOH, 2006)
Tamanho do código
compilado
Número de ciclos Memória de
Dados
FIR (RV32IM) 296 bytes
12240 672 bytes
FIR(XOolong) 152 bytes
6120 336 bytes
Para avaliação da instrução cmul na implementação de moduladores (demoduladores)
digitais, utilizando modulação complexa (BPSK, 4QAM, 16QAM), foi desenvolvida uma
aplicação de modem nos moldes da Figura 47, incluindo o escalonador de tarefas. A tabela 17
resume os resultados da execução destas modulações, para o processamento de 1 byte,
utilizando um esquema de 8 amostras por símbolo e amostragem de 8KSPS.
O speedup da instrução cmul nesta aplicação é calculado de acordo com a lei de Amdahl
(HENNESSY; PATTERSON, 2012), onde o speedup S é definido por:
( )
, (8.1)
onde P é a fração da aplicação a ser otimizada, e si é o speedup da instrução que foi
otimizada. Com isto, encontrou-se um speedup de 19% nas aplicações de modem complexo.
Embora a aceleração da instrução cmul individualmente seja de 8 vezes, dentre as etapas para
modulação, ela é efetivamente utilizada em apenas 18,2% da aplicação completa. Este
resultado pode ser melhorado com a introdução de novas instruções que acelerem o
processamento de cadeias de caracteres e operações em nível de bit, que não foram incluídas
neste trabalho.
Tabela 17 - Execução do modulador complexo (BPSK, 4QAM, 16QAM)
RV32IM RV32IMXOolong %
Ciclos para execução 1050 890
Speedup da instrução - 8
Fração otimizada - 0,182 18,2%
Speedup da Tarefa - 1,19 19%
95
Do ponto de vista da qualidade do sinal modulado, a Figura 52 mostra a captura de tela do
espectro do sinal BPSK modulado em uma portadora de 20MHz, utilizando um analisador de
espectro Rigol DSA-815TG. É possível avaliar a razão sinal/ruído do sinal modulado e
transmitido, através da interface de RF desenvolvida para o barramento WISHBONE. O sinal
da Figura 50 apresenta uma SFDR de aproximadamente 50dB, tendo sido utilizado para
conversão digital-analógica o DAC AD9762, da Analog Devices (ANALOG, 2000).
Figura 52 - Espectro do sinal modulado em BPSK
Para execução do algoritmo AES-128 utilizou-se como base uma implementação open-
source, disponível em (“tiny-AES128-C”, [s.d.]). Os resultados obtidos com a execução do
AES-128 são listados na Tabela 18.
Tabela 18 - Execução do AES-128, em ciclos de clock, para uma entrada de 64 bytes
RV32IM RV32IMXOolong Speedup
Cifragem 124808 116168 7%
Decifragem 1074082 728482 32%
Conclusões 8.7.
Neste capítulo foram discutidos os resultados experimentais da implementação da
arquitetura proposta em FPGA, junto com a descrição do software de suporte às aplicações e
os testes realizados.
96
A descrição em nível RTL da arquitetura utilizou 3098 linhas de código VHDL, e o
software de suporte (escalonador, drivers e sistema de arquivos) foi implementado em 1617
linhas de código em linguagem C.
O sistema completo foi capaz de executar tarefas básicas de um modem, com speedup de
19% quando comparado execução utilizando apenas as instruções padrão do RISC-V.
97
9
Conclusões e Trabalhos Futuros
Conclusões 9.1.
Este trabalho apresentou o desenvolvimento de uma plataforma completa de hardware
(processador com instruções de aplicação específica e periféricos) e software (escalonador de
tarefas, sistema de arquivos e drivers de periféricos) para o desenvolvimento de aplicações de
software-defined radio.
O hardware é centrado em um processador de três estágios de pipeline, previsão de desvios
estática e uma arquitetura de conjunto de instruções RISC-V. Esta arquitetura de processador
tem seu desenvolvimento recente, tendo sido publicada como uma especificação aberta no ano
de 2014. Desde então, tem despertado o interesse tanto da academia como da indústria por
suas características, principalmente pelo seu suporte à introdução de extensões ao conjunto de
instruções, customizadas para aplicações específicas.
As instruções da extensão proposta foram desenvolvidas com objetivo de melhorar o
desempenho do processador nas aplicações de processamento de banda base, sobretudo na
execução das tarefas de um modem. Para isto foi explorada a aritmética de números
complexos, e operações para aceleração do algoritmo de criptografia AES. O speedup destas
instruções para uma aplicação de modem, incluindo o overhead do escalonamento, foi de
19%, para as modulações BPSK, 4QAM e 16QAM. Para a operação de decriptação do AES,
utilizando as novas instruções propostas, o speedup obtido foi de 32% na comparação com a
mesma tarefa sendo executada utilizando apenas as instruções padrão da arquitetura RISC-V.
De maneira geral, a plataforma utiliza poucos recursos de hardware, incluindo memória de
programas e dados, sendo adequada a utilização em FPGAs de baixo custo, como os das
famílias Cyclone II e III da Altera.
98
Além do hardware, neste trabalho também foi desenvolvido o software de suporte às
aplicações, incluindo o escalonador de tarefas, seguindo o modelo do escalonamento de
tarefas implementado no GNURadio, com limitações de processamento, tamanho de código e
uso de memória. Desta maneira o conjunto da plataforma proposta, como mostra a tabela, se
posiciona como uma solução intermediária no fluxo de projeto de sistemas de processamento
de banda base, adaptando vantagens da prototipação em alto nivel de abstração do GNURadio
às realidades e limitações de um sistema embarcado, numa etapa de projeto anterior à que
utiliza soluções como as apresentadas nos demais trabalhos.
Tabela 19- Comparativo entre os Trabalhos Relacionados e a Solução Proposta
(Tell, et
al., 2007)
(RAMACH
ER et al.,
2011)
(LEE;
CHAKRA
BARTI;
MUDGE,
2010)
(CHEN et
al., 2016)
(GNU
Radio)
Trabalho
proposto
Aplicação DVB/Wi
Max
LTE WCDMA IoT Genérico Genérico/ IoT
Linguagem C/Assembly C/Assembly C/Assembly C/Assembly C/Python C/Assembly
Aritmética Complexos
/Ponto Fixo Ponto Fixo Ponto
Fixo
Ponto Fixo Ponto
Flutuante
Complexos/
Ponto Fixo
Aceleração
de
Criptografia
Não Não Não Não x86:
AES-NI
Instrução
PXMUL
Tecnologia
de Projeto
CMOS CMOS CMOS CMOS SW FPGA
Ferramentas
de software
Proprietária Proprietária Proprietária Proprietária Open-
source
GPL
GCC
Trabalhos Futuros 9.2.
A arquitetura proposta neste trabalho pode ser extendida, com a inclusão de instruções de
aplicação específica adicionais, para processamento de banda base ou outras aplicações, ou de
outros perífericos de suporte ou coprocessadores. Para melhorar o desempenho no algoritmo
AES, e em outros algoritmos de criptografia, é interessante a implementação de um
coprocessador específico para esta aplicação.
O núcleo do processador RISC-V pode ser complementado, adicionando outras extensões
padrão da arquitetura, de modo a habilitar o suporte à sistemas multicore ou manycore e, com
99
a adição de uma unidade de gerenciamento de memória (MMU), o suporte à sistemas
operacionais, como GNU Linux.
No hardware externo ao FPGA/processador, um front-end de RF com maior faixa de
frequências de operação pode ser projetado, viabilizando a implementação de sistemas de
software-defined radio, e proporcionando o desenvolvimento de sistemas de comunicação
ativos, embora estes já se enquadrem dentro do paradigma de cognitive radio.
100
Referências
AGÊNCIA NACIONAL DE TELECOMUNICAÇÕES. planodeatribuicao.jpg
(4961×3508). Disponível em:
<http://www.anatel.gov.br/setorregulado/images/artigos/planodeatribuicao.jpg>. Acesso em:
24 jul. 2016.
ALTERA. AN 455: Understanding CIC Compensation Filters. 2007.
ALTERA. Cyclone III Device HandbookSan Jose, 2012.
ANALOG, D. AD9762 (Rev. B) Datasheet. 2000.
ANALOG, D. SHARC Processors | Analog Devices. Disponível em:
<http://www.analog.com/en/products/processors-dsp/sharc.html>. Acesso em: 1 jul. 2016.
ANJUM, O. et al. State of the art baseband DSP platforms for Software Defined Radio: A
survey. EURASIP Journal on Wireless Communications and Networking, v. 2011, n. 1,
p. 5, 2011.
ARM, L. ARM Information Center. Disponível em:
<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0432c/index.html>. Acesso
em: 1 jul. 2016.
ARM, L. ARM Information Center. Disponível em:
<http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/4160.html>. Acesso em:
1 jul. 2016.
BOYER, R. S.; MOORE, J. S. A fast string searching algorithm. Communications of the
ACM, v. 20, n. 10, p. 762–772, 1 out. 1977.
CHEN, Y. et al. A low power software-defined-radio baseband processor for the Internet
of Things. 2016 IEEE International Symposium on High Performance Computer Architecture
(HPCA). Anais...IEEE, mar. 2016Disponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=7446052>. Acesso em: 12
ago. 2016
DAEMEN, J.; RIJMEN, V. The Advanced Encryption Standard Process. In: [s.l: s.n.]. p. 1–8.
DEWEY, A. VHSIC Hardware Description (VHDL) Development Program. 20th Design
Automation Conference Proceedings. Anais...IEEE, 1983Disponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1585720>. Acesso em: 12
ago. 2016
101
Ettus Research - The leader in Software Defined Radio (SDR). Disponível em:
<https://www.ettus.com/>.
EUCLID. The thirteen books of Euclid’s Elements. [s.l.] Encyclopaedia Britannica, 1956.
v. 3
FORUM, W. I. What is Software Defined Radio Software Defined Radio -
DefinedWireless Innovation Forum, , 2014. Disponível em:
<http://www.wirelessinnovation.org/assets/documents/SoftwareDefinedRadio.pdf>. Acesso
em: 12 ago. 2016
FUJISAWA, T. et al. A single-chip 802.11a MAC/PHY with a 32-b RISC processor. IEEE
Journal of Solid-State Circuits, v. 38, n. 11, p. 2001–2009, nov. 2003.
GAJSKI, D. D. et al. Embedded System Design. Boston, MA: Springer US, 2009.
GAJSKI, D. D.; ZHU, J.; DÖMER, R. Essential Issues in Codesign. In: Hardware/Software
Co-Design: Principles and Practice. Boston, MA: Springer US, 1997. p. 1–45.
GCC. Inline - Using the GNU Compiler Collection (GCC). Disponível em:
<https://gcc.gnu.org/onlinedocs/gcc/Inline.html>. Acesso em: 1 jul. 2016.
GENTILE, K. Section 11. Ancillary DDS Techniques, Features, and Functions. 1999.
GNURADIO. Guided Tutorial Introduction - GNU Radio - gnuradio.org. Disponível em:
<http://gnuradio.org/redmine/projects/gnuradio/wiki/Guided_Tutorial_Introduction>. Acesso
em: 1 ago. 2016.
GNURADIO. GNU Radio. Disponível em: <http://gnuradio.org/>. Acesso em: 1 jul. 2016.
GOH, W. MSP430 Competitive Benchmarking. 2006.
GRAYVER, E. Standardization efforts for software-defined radio. IEEE Aerospace
Conference Proceedings, 2010.
GUTHAUS, M. R. et al. MiBench: A free, commercially representative embedded
benchmark suite. Proceedings of the Fourth Annual IEEE International Workshop on
Workload Characterization. WWC-4 (Cat. No.01EX538). Anais...IEEE, 2001Disponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=990739>. Acesso em: 12
ago. 2016
HENNESSY, J. L.; PATTERSON, D. A. Computer architecture: a quantitative approach.
[s.l: s.n.].
HOGENAUER, E. A class of digital filters for decimation and interpolation. ICASS ‟80.
IEEE International Conference on Acoustics, Speech, and Signal Processing. Anais...Institute
of Electrical and Electronics Engineers, 1980Disponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=1170846>. Acesso em: 12
102
ago. 2016
KONG, J. et al. Next-generation consumer audio application specific embedded processor.
Proceedings of the 2010 IEEE 8th Symposium on Application Specific Processors,
SASP’10, p. 1–7, 2010.
KUROSE, J. F.; ROSS, K. W. Computer networking : a top-down approach. [s.l.]
Addison-Wesley, 2010.
LEE, H.; CHAKRABARTI, C.; MUDGE, T. A Low-Power DSP for Wireless
Communications. IEEE Transactions on Very Large Scale Integration (VLSI) Systems, v.
18, n. 9, p. 1310–1322, set. 2010.
LEE, Y. et al. Spike, a RISC-V ISA Simulator. Disponível em:
<https://github.com/riscv/riscv-isa-sim>.
LEE, Y. et al. A 45nm 1.3GHz 16.7 double-precision GFLOPS/W RISC-V processor with
vector accelerators. ESSCIRC 2014 - 40th European Solid State Circuits Conference
(ESSCIRC). Anais...IEEE, set. 2014bDisponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=6942056>. Acesso em: 12
ago. 2016
LIU, D. Embedded DSP Processor Design. [s.l.] Morgan Kaufmann, 2008. v. 1
LIU, D. Baseband ASIP design for SDR. China Communications, v. 12, n. 7, p. 60–72, jul.
2015.
MA, S. et al. Porting GNU Radio to Multicore DSP+ARM SoC A Purely Open Source
Approach Who Am I? Embedded Linux Conference. Anais...2014
MILAER. RADIO COMMUNICATIONS: Air Force orders Harris software-defined
radios for special ops - Military & Aerospace Electronics. Disponível em:
<http://www.militaryaerospace.com/articles/print/volume-25/issue-10/product-
applications/radio-communications-air-force-orders-harris-software-defined-radios-for-
special-ops.html>. Acesso em: 1 jul. 2016.
MILLER, B.; VAHID, F.; GIVARGIS, T. RIOS: A Lightweight Task Scheduler for
Embedded Systems. WESE‟12. Anais...Tampere, Finland: 2012
MOORE, G. E. Cramming More Components Onto Integrated Circuits. Proceedings of the
IEEE, v. 86, n. 1, p. 82–85, jan. 1998.
MORAWIEC, A.; HINDERSCHEIT, J. The 2012 Conference on Design &
Architectures for Signal & Image Processing (DASIP) Karlsruhe, Germany,
October 23-25, 2012. [s.l.] ECSI, 2012.
NILSSON, A. et al. Design methodology for memory-efficient multi-standard baseband
103
processors. 2005 Asia-Pacific Conference on Communications, v. 2005, n. October, p. 28–
32, 2005.
NILSSON, A. Design of programmable multi-standard baseband processors processors.
[s.l: s.n.].
OPENCORES. Wishbone B4 WISHBONE System-on-Chip (SoC)Interconnection
Architecturefor Portable IP Cores Brought to You By OpenCores. 2010.
OSHANA, R. DSP for embedded and real-time systems. [s.l.] Newnes, 2012.
PATTERSON, D. A.; HENNESSY, J. L. Computer Organization and Design, 4th Ed, D.
A. Patterson and J. L. Hennessy.pdf. [s.l: s.n.]. v. 4th
PODIVINSKY, J. et al. FPGA Prototyping and Accelerated Verification of ASIPs. 2015
IEEE 18th International Symposium on Design and Diagnostics of Electronic Circuits &
Systems. Anais...IEEE, abr. 2015Disponível em:
<http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=7195687>. Acesso em: 12
ago. 2016
PROAKIS, J. G. Digital communications. [s.l.] McGraw-Hill, 2001.
RAMACHER, U. et al. Architecture and implementation of a Software-Defined Radio
baseband processor. Proceedings - IEEE International Symposium on Circuits and
Systems, p. 2193–2196, 2011.
TANENBAUM, A. S. Structured computer organization. [s.l.] Pearson Prentice Hall,
2006.
TANENBAUM, A. S.; AUSTIN, T. Structured computer organization. [s.l.] Pearson,
2013.
TELL, E. Design of Programmable Baseband Processors. [s.l: s.n.].
TELL, E.; NILSSON, A.; LIU, D. A low area and low power programmable baseband
processor architecture. Proceedings - Fifth International Workshop on System-on-Chip
for Real-Time Applications, IWSOC 2005, v. 2005, p. 347–351, 2005a.
TELL, E.; NILSSON, A.; LIU, D. A programmable DSP core for baseband processing. 3rd
International IEEE Northeast Workshop on Circuits and Systems Conference,
NEWCAS 2005, v. 2005, p. 403–406, 2005b.
EXAS, I. S320C5x GeneralĆ urpose Applications User‟s Guide 1997 Digital Signal
Processing Solutions. 1997.
TEXAS, I. Specification CAL000. [s.l: s.n.]. Disponível em: <http://cryptome.org/ti-
calypso1.pdf>. Acesso em: 12 ago. 2016.
tiny-AES128-C. Disponível em: <https://github.com/kokke/tiny-AES128-C>. Acesso em: 1
104
jul. 2016.
TOCCI, R. J.; WIDMER, N. S.; MOSS, G. L. Digital systems : principles and applications.
[s.l.] Pearson Prentice Hall, 2007.
UL HAQ, S. et al. Bulk Encryption on GPUs - AMD. Disponível em:
<http://developer.amd.com/resources/articles-whitepapers/bulk-encryption-on-gpus/>. Acesso
em: 1 jul. 2016.
VAHID, F.; GIVARGIS, T. Embedded system design : a unified hardware/software
introduction. [s.l.] Wiley, 2002.
WALDROP, M. M. More than Moore. Nature, fev. 2016.
WATERMAN, A. et al. The RISC-V Instruction Set Manual Volume I: User-Level ISA
Version 2.0. 2014.
YORK, R. Benchmarking in context: DhrystoneARM, , 2002. Disponível em:
<http://dell.docjava.com/courses/cr346/data/papers/DhrystoneMIPS-CriticismbyARM.pdf>.
Acesso em: 12 ago. 2016
105
Anexo A - listagem das instruções
propostas
Neste anexo são detalhadas as instruções da extensão ao conjunto de instruções RISC-V,
proposta neste trabalho. As instruções são do tipo R, operando sobre valores armazenados no
banco de registradores. A descrição das instruções é feita considerando os seguintes
parâmetros:
Tipo de Instrução – Breve descrição da instrução, tipo de dados em que opera.
Sintaxe – apresenta o formato da instrução em código assembly
Operandos - registradores de destino e de origem dos dados
Execução – a operação realizada pela instrução
Descrição – descrição funcional da operação
A notação para a execução das instruções é dada pela seguinte forma:
R|I : Parte real do número complexo armazenado noregistrador R
R|Q : Parte imaginária donúmero complexo armazenado no registrador R.
R|B0: bits 7 a 0 do vetor armazenado no registrador R
R|B1: bits 15 a 8 do vetor armazenado no registrador R
R|B2: bits 23 a 16 do vetor armazenado no registrador R
R|B3: bits 31 a 24 do vetor armazenado no registrador R
106
CADD
Tipo de Instrução:
Instrução da CALU. Soma de dois números complexos.
Sintaxe:
cadd rd, rs1,rs2
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
rs2 : Registrador de origem 2 (x0 – x31)
Execução:
rd ← rs1|I + rs2|I , rs1|Q + rs2|Q
Descrição:
A instrução retorna o valor da soma de dois números complexos, em representação de ponto
fixo, com precisão de 16 bits para as partes real e imaginária. Em caso de overflow, uma flag
é habilitada.
CSUB Tipo de Instrução:
Instrução da CALU. Subtração de dois números complexos.
Sintaxe:
csub rd, rs1,rs2
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
rs2 : Registrador de origem 2 (x0 – x31)
Execução:
rd ← rs1|I −rs2|I , rs1|Q − rs2|Q
Descrição:
107
A instrução retorna o valor da subtração de dois números complexos, em representação de
ponto fixo, com precisão de 16 bits para as partes real e imaginária. Em caso de underflow,
uma flag é habilitada.
CCONJ Tipo de Instrução:
Instrução da CALU. Conjugado de um número complexo.
Sintaxe:
cconj rd, rs1
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
Execução:
rd ← rs1|I, −rs1|Q
Descrição:
A instrução retorna o valor do conjugado de um número complexo armazenado no registrador
rs1, escrevendo o resultado da operação no registrador rd, com precisão de 16 bits para as
partes real e imaginária.
CMUL Tipo de Instrução:
Instrução da unidade CMAC. Multiplicação de dois números complexos.
Sintaxe:
cmul rd, rs1,rs2
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
rs2 : Registrador de origem 2 (x0 – x31)
Execução:
rd|I ← e{rs1 ×rs2}
rd|Q ← Im{rs1× rs2}
Descrição:
108
A instrução retorna o valor da multiplicação de dois números complexos, em representação de
ponto fixo, com precisão de 16 bits para as partes real e imaginária. Em caso de overflow,
uma flag é habilitada.
CMAC
Tipo de Instrução:
Instrução da unidade CMAC. Multiplicação e acumulação de dois números complexos.
Sintaxe:
cmac rd, rs1,rs2
Operandos:
rd : Registrador de destino/origem1 (x0 – x31)
rs1 : Registrador de origem 2 (x0 – x31)
rs2 : Registrador de origem 3 (x0 – x31)
Execução:
rd|I ← e{rd + (rs1 × rs2)}
rd|Q ←Im{rd + (rs1 × rs2)}
Descrição:
A instrução retorna o valor da multiplicação e acumulação de dois números complexos, em
representação de ponto fixo, com precisão de 16 bits para as partes real e imaginária. Em caso
de overflow, uma flag é habilitada.
CSMUL Tipo de Instrução:
Instrução da unidade CMAC. Multiplicação de um númerocomplexo por um escalar.
Sintaxe:
csmul rd, rs1,rs2
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
rs2 : Registrador de origem 2 (x0 – x31)
109
Execução:
rd ← rs1 × rs2|I , rs1 × rs2|Q
Descrição:
A instrução retorna o valor da multiplicação de um número complexo por um escalar, em
representação de ponto fixo, com precisão de 16 bits para as partes real e imaginária. Em caso
de overflow, uma flag é habilitada.
CABS
Tipo de Instrução:
Instrução da unidade CMAC. Quadrado da norma de um número complexo
Sintaxe:
cabs rd, rs1
Operandos:
rd : Registrador de destino (x0 – x31)
rs1 : Registrador de origem 1 (x0 – x31)
Execução:
rd ← (rs1|I )² + (rs1|Q )²
Descrição: A instrução retorna o valor do quadrado da norma (módulo) de um número
complexo, em representação de ponto fixo, com precisão de 16 bits para as partes real e
imaginária.
PXMUL Tipo de Instrução:
Instrução da unidade CALU. Multiplicação de um polinômio pelo polinômio x, no campo
GF(28). Instrução para aceleração do algoritmo AES.
Sintaxe:
pxmul rd, rs1,rs2
Operandos:
rd : Registrador de destino/origem1 (x0 – x31)
rs1 : Registrador de origem 2 (x0 – x31)
rs2 : Registrador de origem 3 (x0 – x31)
Execução:
rd ← rd|I + (rs1|I × rs2|I), rd|Q + (rs1|Q × rs2|Q)
110
Descrição:
A instrução retorna o valor da multiplicação e acumulação de dois números complexos, em
representação de ponto fixo, com precisão de 16 bits para as partes real e imaginária. Em caso
de overflow, uma flag é habilitada.
VADD Tipo de Instrução:
Instrução da unidade CALU, utilizando paralelismo SIMD. Adição byte a byte entre dois
vetores de 4 bytes.
Sintaxe:
vadd rd, rs1,rs2
Operandos:
rd : Registrador de destino/origem1 (x0 – x31)
rs1 : Registrador de origem 2 (x0 – x31)
rs2 : Registrador de origem 3 (x0 – x31)
Execução:
rd ← rs1|B3 + rs2|B3, rs1|B2 + rs2|B2, rs1|B1 + rs2|B1, rs1|B0 + rs2|B0
Descrição:
A instrução retorna o valor da adição entre os componentes de dois vetores de 4 bytes.
VMUL Tipo de Instrução:
Instrução da unidade CALU, utilizando paralelismo SIMD. Multiplicação byte a byte entre
dois vetores de 4 bytes.
Sintaxe:
vmul rd, rs1,rs2
Operandos:
rd : Registrador de destino/origem1 (x0 – x31)
rs1 : Registrador de origem 2 (x0 – x31)
rs2 : Registrador de origem 3 (x0 – x31)
Execução:
rd ← rs1|B3 × rs2|B3, rs1|B2 × rs2|B2, rs1|B1 × rs2|B1, rs1|B0 × rs2|B0
111
Descrição:
A instrução retorna o valor da multiplicação entre os componentes de dois vetores de 4 bytes.
VMAC Tipo de Instrução:
Instrução da unidade CALU, utilizando paralelismo SIMD. Multiplicação com acumulação
byte a byte entre dois vetores de 4 bytes.
Sintaxe:
vmac rd, rs1,rs2
Operandos:
rd : Registrador de destino/origem1 (x0 – x31)
rs1 : Registrador de origem 2 (x0 – x31)
rs2 : Registrador de origem 3 (x0 – x31)
Execução:
rd ← rd|B3 + (rs1|B3 × rs2|B3), rd|B2 + (rs1|B2 × rs2|B2), rd|B1 + (rs1|B1 × rs2|B1), rd|B0 +
(rs1|B0 × rs2|B0)
Descrição:
A instrução retorna o valor da multiplicação com acumulação entre os componentes de dois
vetores de 4 bytes.
![Guia American Blonde Ale · 2019-12-11 · Ale, Widmer Blonde Ale, Fuller’s Summer Ale, Hol-lywood Blonde, Redhook Blonde Receita [eBook] Guia American Blonde Ale Receita para 20](https://static.fdocumentos.com/doc/165x107/5f812a789d61c821a373f1aa/guia-american-blonde-ale-2019-12-11-ale-widmer-blonde-ale-fulleras-summer.jpg)
![Sistemas Digitais - Princípios e aplicações [Ronald J. Tocci-Neal S. Widmer]](https://static.fdocumentos.com/doc/165x107/55cf9e3b550346d033b07702/sistemas-digitais-principios-e-aplicacoes-ronald-j-tocci-neal-s-widmer-565f26299f798.jpg)