GAPH - PPGCC - FACIN - PUCRS

GAPH - PPGCC - FACIN - PUCRS
GAPH - FACIN - PUCRS Síntese e Prototipação de Sistemas Digitais a partir de SystemC 1º/03/2004 a 05/03/2005 Ney Laert Vilar Calazans GAPH - PPGCC - FACIN - PUCRS

Sumário Introdução - SystemC, Síntese, Prototipação
Estudos de Caso de Módulos RTL em SystemC Usando o Subconjunto Sintetizável de SystemC Diretivas de Codificação RTL para SystemC Modelagem e Síntese Comportamental

Introdução - SystemC, Síntese, Prototipação
Projeto a nível de sistema, linguagens sistêmicas e níveis de abstração apresentação G. Arnout, ESCUG Out/2002 Nem tudo que se escreve em SystemC é transformável em hardware: tudo é simulável (em tese!) simulação pode não funcionar - timing é importante! nem tudo é sintetizável - subconjunto sintetizável de SystemC o que sintetiza não necessariamente funciona! nem tudo é prototipável/implementável questões tecnológicas + interfaces externas + padrões E/S

Documentação (Versão de SystemC) Synopsys,Inc. Describing Synthesizable RTL in SystemC. Version 1.2, November p. (Manual Synopsys RTL) OSCI. Functional Specification for SystemC 2.0. Update for SystemC Version 2.0-Q. April p. OSCI. SystemC Version 2.0 User Guide. Update for SystemC Version 2.0-Q p. OSCI. SystemC Language Reference Manual. Revision p. Manuais de ferramentas Synopsys: CoCentric SystemC Compiler, Design Compiler, CoCentric SystemC Studio, CoCentric Fixed Point Designer, etc.

Porque sintetizar a partir de SystemC? HDLs são estáveis e dominadas Specs - C é quase padrão, junto com planilhas, Matlab, etc Tradução C -> HDL - propensa a erros de interpretação Reuso de verificação - evita re-escrita de código de verificação Produtividade aumentada modificar um projeto - mais rápido que recodificá-lo verificar projeto modificado - mais rápido que verificar recodificado

Porque prototipar? Se simulação OK, projeto funciona em hardware? NÃO!!!! Caminho de simulação perfeita para funcionamento em hardware é longo O que ainda pode estar errado? Timing - freqüência de operação, Código de verificação insuficiente Condições iniciais e de contorno - reset, pinagem, clock, etc. Prototipação dá garantia muito maior que a implementação final funcionará. Logo, prototipar sempre é a regra!

Questionário Quem já programou algo em SystemC? Usando que ferramentas? Quem já simulou hardware? Usando que forma de entrada, que software, que ferramentas? Quem já simulou algo descrito em SystemC? Usando que ferramentas? Quem já prototipou hardware? Usando que forma de entrada, que software, que plataforma? Quem já prototipou hardware a partir de descrições de entrada em SystemC? Usando que software, que plataforma?

Ambiente a ser usado no curso Linguagem de entrada - SystemC Ferramentas de simulação - GTKwave - domínio público porque não CoCentric SystemC Studio? Ferramentas de Síntese - Design Compiler/CoCentric SystemC Compiler Ambiente de prototipação: CAD ISE da Xilinx (projeto, sínteses lógica e física e configuração) Plataformas variadas de prototipação em FPGAs Xilinx (+ SW específico) V2MB1000 Insight XSV-800 da Xess VW300 da VCC

Como criar Módulos RTL em SystemC Usando o Subconjunto Sintetizável de SystemC Diretivas de Codificação RTL para SystemC Modelagem e Síntese Comportamental

Características Gerais de Módulos e Processos
Módulo (SC_MODULE) Bloco básico para a construção de hardware Eqüivale a module Verilog e par entity/architecture VHDL Pode conter: processos instâncias de outros módulos member functions (terminologia C++) chamadas por processos ou módulos internos Processos (SC_METHOD) trecho de código executado seqüencialmente múltiplos processos paralelos -> concorrência

Outros módulos podem estar instanciados internamente

Registro de processos Processo - definição similar a member function C++ registro - declaração do tipo de processo no construtor SC_METHOD (SC_THREAD proibido em SystemC RTL) registro diferencia processo paralelo de outras member functions se processo precisa ser instanciado mais de uma vez, deve estar dentro de módulo, senão erro! Disparo de execução de processos baseado na definição da lista de sensitividade sensitividade - ao nível/à borda (imisturável em processo!)

Leitura e escrita de valores por processos processo pode ler escrever em portas (sc_in, sc_out, sc_inout) sinais internos ao módulo (signal) variáveis internas (ao processo) evitar não-determinismo: não faça processos se comunicarem via variáveis usar sinais!!! (Como obrigado em VHDL)

Sintaxe e Semântica de Módulos de Processos
Usar 1 par de arquivos por módulo (.h e .cc) Cabeçalho de módulos declarações de portas declarações de sinais internos declarações de variáveis internas declarações de processo declarações de member functions construtor do módulo

Portas de um módulo porta é data member (nomenclatura C++) de um módulo portas se conectam a sinais de mesmo tipo tipo de porta deve ser sintetizável!!

Sinais usados para comunicação entre processos e/ou módulos sinais não possuem direção!!

Variáveis de módulo (data members) devem ser usadas para uso interno ao módulo apenas!!

Criando processos em módulos declarados no módulo e registrados no construtor deste processo - função com tipo void, sem argumentos

Lista de sensitividade sensitive() ou sensitive_pos() ou sensitive_neg() -- deprecated lógica combinacional - incluir todos os sinais de entrada! Lógica seqüencial síncrona - incluir só clock e sinais com prioridade sobre este, tais como set/reset assíncronos, se existem. Sensitividade ao nível

Sensitividade à Borda Lista de sensitividade incompleta (Errado!!)

Limitações de listas de sensitividade não se pode misturar sensitividade ao nível e à borda no mesmo processo não se pode usar o tipo sc_logic para sinais de relógio ou outros sinais sensíveis à borda, usa-se somente o tipo sc_in<bool> Member functions possíveis de serem declaradas em módulos se não declaradas como processo (SC_METHOD) podem retornar qualquer tipo sintetizável

Implementação do Módulo arquivo .cc /.cpp Leitura e escrita de portas e sinais métodos read() e write() para portas e sinais, = p/ variáveis

Leitura e escrita de bits de portas e sinais não se pode ler/escrever bits de portas ou sinais direto para bits individuais ou faixas, usar variáveis temporárias

Atribuições de valor a sinais e portas a atribuição não se concretiza até que a avaliação do processo seja concluída!

Atribuições de valor a variáveis são imediatas!

Estudos de Caso de Implementação de Módulos
Módulos com processo SC_METHOD único exemplo de contador combinacional de zeros (paralelo) Módulos com múltiplos processos SC_METHOD exemplo de contador seqüencial de zeros (serial) Módulos RTL hierárquicos ver exemplo do filtro FIR (ver manual Synopsys RTL)

Módulos com Processo SC_METHOD Único
/****count_zeros_comb.h file***/ #include "systemc.h" SC_MODULE(count_zeros_comb) { sc_in<sc_uint<8> > in; sc_out<sc_uint<4> > out; sc_out<bool> error; bool legal(sc_uint<8> x); sc_uint<4> zeros(sc_uint<8> x); void control_proc(); SC_CTOR(count_zeros_comb) { SC_METHOD(control_proc); sensitive << in; } }; /****count_zeros_comb.cpp file****/ #include "count_zeros_comb.h" sc_uint<4> count_zeros_comb:: zeros(sc_uint<8> x) { int count = 0; for (int i=0; i <= 7; ++i) { if (x[i] == 0) ++count; } return count; void count_zeros_comb::control_proc() { sc_uint<4> tmp_out; bool is_legal = legal(in.read()); error.write(is_legal != 1); is_legal ? tmp_out = zeros(in.read()) : tmp_out = 0; out.write(tmp_out); } bool count_zeros_comb::legal(sc_uint<8> x) { bool is_legal = 1; bool seenZero = 0; bool seenTrailing = 0; for (int i=0; i <=7; ++i) { if ((seenTrailing == 1) && (x[i] == 0)) { is_legal = 0; break; } else if ((seenZero == 1) && (x[i] == 1)) { seenTrailing = 1; } else if (x[i] == 0) { seenZero = 1; } } return is_legal; }

Módulos com Múltiplos Processos SC_METHOD
Ver código SystemC no manual Synopsys RTL

Módulos RTL Hieráquicos
Passos básicos para a criação de módulos hieráquicos: criar ponteiros como data members no módulo de nível de hierarquia mais alto para apontar cada instância de módulo alocar os módulos instanciados dentro do construtor do módulo de nível de hierarquia mais alto, dando a cada um nome distinto conectar as portas dos módulos instanciados às portas e sinais do módulo de nível de hierarquia mais alto Ver exemplos no manual Synopsys RTL atentar para o uso sintetizável de ponteiros

Conversão para o Subconjunto Sintetizável
Lembrando, qualquer código SystemC/C/C++ pode ser simulado! conversão p/ SystemC sintetizável - apenas no código Hw recomenda-se o uso de #ifdef e #endif para evitar alterações. Ex: trace e print Nesta parte - especificação dos subconjuntos sintetizáveis de SystemC e C++ ações corretivas - geram código sintetizável a partir de código não-sintetizável em muitos casos - nenhuma ação corretiva existe!! óbvio - testbenches não precisam de conversão jamais!!

Construções SystemC não-sintetizáveis

Construções C/C++ não-sintetizáveis (1)

Modificação de Dados para Síntese
Problemas mais comuns: tipos nativos C/C++ - largura em bits é dependente de plataforma C/C++ não suporta operações sobre lógica de 4 valores (0,1,Z,X) SystemC - conjunto limitado de tipos com controle de precisão/largura e operações sobre estes Para modificar SystemC para síntese RTL avaliar - declarações de variáveis, parâmetros formais e tipos de retorno de funções quanto à largura em bits isto afeta diretamente o custo do hardware!

Tipos de dados não-sintetizáveis C/C++/SystemC ponto flutuante - float, double ponto fixo - sc_fixed, sc_ufixed, sc_fix, sc_ufix tipos de acesso - ponteiros tipos arquivo - FILE streams de entrada e saída - stdout, cout

Tipos de dados recomendados variáveis/sinais de 1 bit - bool variáveis/sinais de até 64bits - sc_int, sc_uint variáveis/sinais com mais de 64bits usados em operações aritméticas - sc_bigint, sc_biguint usar sc_logic ou sc_lv para modelar sinais e barramentos tristate. Comparações com valores Z e X -> não-sintetizáveis usar int para contadores em laços cuidado com tipos nativos C/C++ para restringir tamanho em bits, sc_int<n> ao invés de int

Tipos de dados sintetizáveis (1)

Tipos de dados sintetizáveis (2)

Operadores sobre vetores de bits

Operadores sobre tipos de dados de precisão simples e arbitrária

Tipos enumerados - suportados como em C/C++ Usando agregados - sintetizável desde que todos os membros o sejam Tipos C++ - cuidado com a dependência de plataforma no que diz respeito à largura em bits Dados membros de um módulo - não usar para comunicação entre processos

Exemplo de uso incorreto de dados-membro Problema relacionado a atribuição imediata/deferida

Exemplo de uso correto de dados-membro Problema relacionado a atribuição imediata/deferida

Recomendações sobre Modificação para Síntese
Após cada modificação, reverifique o projeto Procure avaliar ambos, o impacto na sintetizabilidade e o impacto na qualidade da síntese a cada passo Refinamento para RTL é tedioso, propenso a erro e incremental próxima Seção recomenda diretivas de codificação para reduzir o problema!

Diretivas de Codificação RTL para SystemC
Existem diretivas de codificação para três classes de componentes RTL: inferência de registradores e latches inferência de buffers tristate descrição de máquinas de estados finitas (FSMs) Aqui - estudo de diretivas de codificação para cada classe acima ênfase em síntese em prototipação ergo, de-ênfase em latches

Diretivas de Codificação RTL para SystemC
Lembrando - SystemC e HDLs (e.g. VHDL, Verilog) sem construções para definir explicitamente componentes RTL (registradores, latches, portas lógicas, buffers, etc) motivo principal - independência de tecnologia!! ferramentas específicas de síntese - inferem componentes RTL!

Inferência de Registradores e Latches
Regra de base ao inferir registradores/latches - sinais de controle/dados controláveis das entradas do projeto inferir registrador/latch com set/reset assíncronos facilita inicialização - RECOMENDÁVEL! Conjuntos de diretivas para inferência de flip-flops/registradores inferência de latches, evitando inferência de latches

Inferência de Registradores
Componente Inferido Código Flip-flop D simples (FFD) usar processo (SC_METHOD) sensível a exatamente uma borda de um sinal de controle síntese RTL cria FFs para todas as variáveis/sinais aos quais são atribuídos valores no processo

/* Rising-edge-triggered DFF */ #include "systemc.h" SC_MODULE (dff3) { sc_in<bool> in_data, reset; sc_out<bool> out_q; sc_in<bool> clock; // clock port void do_dff_pos (); // Constructor SC_CTOR (dff3) { SC_METHOD (do_dff_pos); sensitive_pos << clock << reset; } }; void dff3::do_dff_pos () { if (reset.read()){ out_q.write(0); }else{ out_q.write(in_data.read()); Componente Inferido Código Flip-flop D com Set ou Reset assíncrono ativo em 1 lembrar - não misturar sensitividade ao nível e à borda ergo, p/ FFs, usar sensitividade à borda para todos os sinais de controle (clock, set/reset, etc)

Componente Inferido Código Flip-flop D com Set e Reset assíncrono ativo em 1 problema aqui é que fazer quando set e reset ativos simultaneamente - estabelecer prioridade! Cuidado! Prioridade pode ser garantida via código, e não pelo processo de inferência - limitações da biblioteca de tecnologia específica

Componente Inferido Código Flip-flop D com Set ou Reset síncrono set/reset não aparece na lista de sensitividade! se componente não existe na biblioteca, inferência usa lógica combinacional na entrada do FF notar: código do processo idêntico ao FF com set/reset assíncrono, só a sensitividade muda diferente de Verilog/VHDL

Flip-flop JK usar comando switch… codificação similar a FFD com set e reset síncronos void jkff1::jk_flop() { sc_uint<2> temp; //temp to create vector temp[1] = j.read( ); temp[0] = k.read( ); switch(temp) { case 0x1: q.write(0); // write a zero break; case 0x2: q.write(1); // write a 1 case 0x3: // toggle q.write(!q.read()); default: break; // no change } /* Rising-edge-triggered JK FF */ #include "systemc.h" SC_MODULE (jkff1) { sc_in<bool> j, k; sc_inout<bool> q; // inout to read q for toggle sc_in<bool> clk; // clock port // Method for D-flip-flop void jk_flop (); // Constructor SC_CTOR (jkff1) { SC_METHOD (jk_flop); sensitive_pos << clk; };

#include "systemc.h" SC_MODULE( tff1 ) { sc_in<bool> set, clk; sc_inout<bool> q; // inout to read q for toggle void t_async_set_fcn (); SC_CTOR( tff1 ) { SC_METHOD( t_async_set_fcn); sensitive_pos << clk << set; } }; void tff1::t_async_set_fcn () { if (set.read()){ q.write(1); }else{ q.write(!q.read()); Componente Inferido Código Flip-flop Toggle com Set assíncrono vários outras combinações com exemplos no manual RTL da Synopsys

Em simulação, uma variável mantém valor até sofrer nova atribuição
Inferência de Latches Em simulação, uma variável mantém valor até sofrer nova atribuição latch implementa esta funcionalidade em hardware freqüentemente, inferência não-intencional, desnecessária e incorreta de latches - problemas na implementação!!! principal fonte de problemas: condições não especificadas em comandos condicionais - EVITAR!!! Síntese RTL suporta latches D e SR aqui, inferência de latch e como evitá-la extensa lista de exemplos adicionais no manual RTL da Synopsys

Latch D inferido a partir de comando if
Inferência de Latches #include "systemc.h" SC_MODULE( d_latch1 ) { sc_in<bool> in_data; sc_in<bool> clock; sc_out<bool> out_q; // Method process void d_latch_fcn () { if (clock.read()) {out_q.write(in_data.read());} } // Constructor SC_CTOR( d_latch1 ) { SC_METHOD( d_latch_fcn); sensitive << in_data << clock; }; Componente Inferido Código Latch D inferido a partir de comando if comando if sem cláusula else leva a inferência de latch! latches são difíceis de testar, pois são escritos sem sinal de relógio hazards combinacionais nas entradas podem causar mudança - síntese RTL de circuitos combinacionais não garante implementação sem hazard!!

Evitando inferência de latches
Componente Inferido Código Evitando inferência de latches atribuir um valor a cada sinal para todas as cláusulas de comando condicional (if, switch, operador condicional ?:)

Inferência de Tristates
Tristate inferido sempre que valor ‘Z’ atribuído a variável Atribuição deve ocorrer em um comando condicional (if, switch ou via operador condicional ?:) Somente os tipos sc_logic e sc_lv suportam o valor ‘Z’

Componente Inferido Código Tristate simples

Componente Inferido Código Tristate com controle associado

// Three-state buffer inference // with resolved logic output #include "systemc.h" SC_MODULE( tristate_ex3 ) { sc_in<bool> in_sela, in_selb; sc_in<sc_logic> in_a, in_b; sc_out_rv<1> out_1; // first three-state driver void tristate_a(); // second three-state driver void tristate_b(); // Constructor SC_CTOR( tristate_ex3 ) { SC_METHOD( tristate_a); sensitive << in_sela << in_a; SC_METHOD( tristate_b); sensitive << in_selb << in_b; } }; void tristate_ex3::tristate_a() { if (in_sela.read()){ out_1.write(in_a.read()); }else{ out_1.write("Z"); void tristate_ex3::tristate_b() { if (in_selb.read()){ out_1.write(in_b.read()); out_1write("Z"); Barramento tristate notar a necessidade do uso de um tipo SystemC resolvido

#include "systemc.h" SC_MODULE( tristate_ex4 ) { sc_in<bool> control; sc_in<sc_logic> data; sc_out<sc_logic> ts_out; sc_in_clk clk; // Method for three-state driver void tristate_fcn () { if (control.read()){ ts_out.write(data.read()); }else{ ts_out.write(’Z’); } // Constructor SC_CTOR( tristate_ex4 ) { SC_METHOD( tristate_fcn); sensitive_pos << clk; } // note inferred seq logic }; Componente Inferido Código Tristate com entradas registradas (ou registrador com saída tristate)

Tristate com entradas registradas e sem controle registrado (registrador com saída tristate) mais comuns que ambas entradas registradas

Descrição de Máquinas de Estado Finitas
Descrições devem ser explícitas FSM = registrador de estado (lógica seqüencial) + função de transição de estados (lógica combinacional) + função de saída (lógica combinacional) Blocos combinacionais podem ser unidos para reduzir área (ajudar a síntese RTL) Entradas e Saídas dependem do estado atual (sempre) e das entradas instantâneas (opcionalmente) Implementações - processo seq + processo comb / processo seq + 2 processos comb / 1 processo (Moore)

Descrição de Máquinas de Estado Finitas
Exemplo do manual Synopsys RTL (Impl. errada!) reset==1 input1==0, input2==0 / a=0, b=0 input1==0, input2==1 / a=1, b=0 S0 input1==1 / a=1, b=0 input2==0 / a=0, b=1 S1 input2==1 / a=0, b=1 - / a=0, b=0 S2 Implementação SystemC do manual corresponde a:

Comparando Modelagens RTL e Comportamental
Modelagem RTL conjunto de registradores e a transferência de informações entre estes no caminho - lógica combinacional processa as informações sistema é uma FSM + recursos de armazenamento/ transformação controlados pela FSM modelo preciso a nível de ciclo de relógio Modelagem comportamental descreve-se a funcionalidade do projeto (algoritmo) projetista não descreve FSM ou recursos (síntese infere) independente de tecnologia e arquitetura de implementação

Comparando Modelagens RTL e Comportamental
Vantagens da modelagem comportamental modelo é menor facilita a captura de algoritmos complexos torna a simulação mais rápida permite acomodar alterações tardias da especificação são mais intuitivos de escrever e entender - mais fáceis de manter aumenta o reuso de projeto aumenta produtividade de projeto e a capacidade de exploração do espaço de soluções de projeto sintetiza automaticamente acessos a memória síncrona

Definição e Passos: Síntese Comportamental
Definição (Jung - SNUG Coréia do Sul) Um processo automatizado de refinar um modelo algorítmico para uma descrição RTL Passos temporizar operações, escalonar cada leitura escrita e operação em um determinado ciclo de relógio alocar componentes (registradores e processamento) criar o bloco de dados com os componentes alocados, interconectando-os com multiplexadores ou barramentos criar a FSM de controle e a lógica de controle da interface de memória

Seleção de Nível de Abstração para Síntese
Escolha síntese RTL se: é mais fácil conceber o sistema como uma FSM e um bloco de dados do que como um algoritmo (e.g. mproc) o projeto deve atender requisitos de altíssimo desempenho o subsistema de memória é complexo (SDRAM/RAMBUS) o projeto é assíncrono

Seleção de Nível de Abstração para Síntese
Escolha síntese comportamental se: é mais fácil conceber o projeto como implementando um algoritmo, e não a partir de uma micro-arquitetura (e. g. uma transformada rápida de Fourier, filtros, quantização inversa) se o projeto possui um fluxo de controle muito complexo (e.g. um processador de rede) se o subsistema de memória acessa memórias síncronas simples

Aplicações para Síntese Comportamental
Comunicação digital - cable modem, telefones celulares, LANs wireless e modems xDSL Processamento de imagem e vídeo - câmeras digitais, impressoras e set-top boxes Redes - chaves ATM e roteadores de pacotes DSP - filtros, codecs e equalizadores de canal Processadores embarcados - controladores de cache, aceleradores e unidades aritméticas de ponto fixo

Exemplos de Codificação RTL e Comportamental
Estilo RTL implementa o projeto como lógica combinacional entre registradores com descrição explícita do bloco de dados e da FSM de controle usa apenas os tipos de dados sintetizáveis de SystemC usa o subconjunto sintetizável da linguagem C++ Exemplo do manual Synopsys RTL (FIFO)

Exemplos de Codificação RTL e Comportamental
Estilo Comportamental comportamento descrito como algoritmo funções usadas para controlar a complexidade do projeto se o modelo inicial possui tipos float, etc, deve-se trocá-los para tipos sintetizáveis SystemC define-se o protocolo de E/S com precisão ao nível de ciclos de relógio usa o subconjunto sintetizável da linguagem SystemC Exemplo do manual Synopsys RTL (FIFO)

GAPH - FACIN - PUCRS FIM

GAPH - PPGCC - FACIN - PUCRS

Apresentações semelhantes

Apresentação em tema: "GAPH - PPGCC - FACIN - PUCRS"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

GAPH - PPGCC - FACIN - PUCRS

Apresentações semelhantes

Apresentação em tema: "GAPH - PPGCC - FACIN - PUCRS"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback