verilator - Online na nuvem

PROGRAMA:

NOME

Verilator - converter código Verilog para C ++ / SystemC

SINOPSE

verificador --ajuda
verificador --versão
verilator --cc [opções] [top_level.v] ... [opt_c_files.cpp / c / cc / a / o / so]
verilator --sc [options] [top_level.v] ... [opt_c_files.cpp / c / cc / a / o / so]
verilator --lint-only [top_level.v] ...

DESCRIÇÃO

Verilator converte código Verilog sintetizável (não comportamental), além de algumas Síntese,
SystemVerilog e um pequeno subconjunto de asserções Verilog AMS, em código C ++ ou SystemC. Isto
não é um simulador completo, mas sim um compilador.

Verilator é invocado com parâmetros semelhantes a GCC, Cadence Verilog-XL / NC-Verilog ou
VCS da Synopsys. Ele lê o código Verilog especificado, lints-o e, opcionalmente, adiciona
cobertura e código de rastreamento de forma de onda. Para os formatos C ++ e SystemC, ele produz .cpp e .h
arquivos.

Os arquivos criados pelo Verilator são compilados com C ++. O usuário escreve um pouco em C ++
arquivo wrapper, que instancia o módulo de nível superior e passa esse nome de arquivo no
linha de comando. Esses arquivos C são compilados em C ++ e vinculados aos arquivos Verilated.

O executável resultante executará a simulação real.

Para começar, vá até "EXEMPLO DE EXECUÇÃO C ++".

ARGUMENTO RESUMO

Este é um breve resumo dos argumentos para Verilator. Veja as descrições detalhadas em
as próximas seções para mais informações.

{file.v} Nomes de arquivos de nível superior Verilog
{file.c / cc / cpp} Arquivos C ++ opcionais para compilar
{file.a / o / so} Arquivos C ++ opcionais para vincular

+ 1364-1995ext + Use Verilog 1995 com extensão de arquivo
+ 1364-2001ext + Use Verilog 2001 com extensão de arquivo
+ 1364-2005ext + Use Verilog 2005 com extensão de arquivo
+ 1800-2005ext + Use SystemVerilog 2005 com extensão de arquivo
+ 1800-2009ext + Use SystemVerilog 2009 com extensão de arquivo
+ 1800-2012ext + Use SystemVerilog 2012 com extensão de arquivo
--assert Habilita todas as asserções
--autoflush Flush streams após todas as exibições de $
--bbox-sys Caixa preta desconhecida $ chamadas de sistema
--bbox-unsup Recursos de idioma não suportados do Blackbox
--bin Substituir binário Verilator
-CFLAGS Sinalizadores do compilador C ++ para makefile
--cc Cria saída C ++
--cdc Análise de cruzamento de domínio de relógio
--clk Marque o sinal especificado como relógio
--compilador Ajuste para o compilador C ++ especificado
--converge-limit Tempo de liquidação de convergência de sintonia
--coverage Habilita toda a cobertura
--coverage-line Habilita cobertura de linha
--coverage-toggle Habilitar cobertura de alternância
--coverage-user Habilita cobertura de usuário SVL
--coverage-underscore Habilita cobertura de _signals
-D [= ] Definir definição de pré-processador
--debug Habilitar depuração
--debug-check Habilita afirmações de depuração
--debugi Habilite a depuração em um nível especificado
--debugi- Habilite a depuração de um arquivo de origem em um nível
--idioma padrão Idioma padrão para analisar
+ definir + = Definir definição de pré-processador
--dump-tree Habilita o despejo de arquivos .tree
--dump-treei Habilite o despejo de arquivos .tree em um nível
--dump-treei- Ative o despejo de arquivo .tree em um arquivo de origem em um nível
-E Pré-processa, mas não compila
- limite de erro Abortar após este número de erros
--exe Link para criar executável
-F Analisar opções de um arquivo, relativamente
-f Opções de análise de um arquivo
--gdb Executa o Verilator no GDB interativamente
--gdbbt Executa o Verilator no GDB para backtrace
--help Mostra esta ajuda
-EU Diretório para pesquisar inclui
--if-depth Aviso de ajuste IFDEPTH
+ incdir + Diretório para pesquisar inclui
--inhibit-sim Criar função para desligar o sim
--inline-mult Módulo de sintonia embutido
-LDFLAGS Sinalizadores de pré-objeto do vinculador para makefile
-LDLIBS Sinalizadores de biblioteca de linker para makefile
--língua Padrão de linguagem padrão para analisar
+ libext + + [ext] ... Extensões para encontrar módulos
--lint-only Lint, mas não gera saída
--MMD Criar arquivos de dependência .d
- MP cria alvos de dependência falsos
--Mdir Nome do diretório do objeto de saída
--mod-prefix Nome para prefixar às classes mais baixas
--no-clk Impedir a marcação do sinal especificado como relógio
--no-pins64 Não use vluint64_t's para sigs de 33-64 bits
--no-skip-idêntico Desabilita o salto de saída idêntica
+ notimingchecks ignorados
-O0 Desativar otimizações
-O3 Otimizações de alto desempenho
-O Otimizações selecionáveis
-o Nome do executável final
--no-order-clock-delay Desabilita o relógio de pedidos habilita atribuições
--output-split Divida os arquivos .cpp em partes
--output-split-cfuncs Dividir funções .cpp
--output-split-ctrace Funções de rastreamento de divisão
-P Desativa números de linha e espaços em branco com -E
--pins-bv Especifique os tipos de portas de nível superior
--pins-sc-uint Especifique os tipos de portas de nível superior
--pins-sc-biguint Especifique os tipos de portas de nível superior
--pins-uint8 Especifique os tipos de portas de nível superior
--pipe-filter Filtre todas as entradas por meio de um script
--prefixo Nome da classe de nível superior
--profile-cfuncs Funções de nome para criação de perfil
- Debugging privado; ver docs
--public Debugging; ver docs
--report-unoptflat Diagnósticos extras para UNOPTFLAT
--savable Habilitar modelo salvar-restaurar
--sc Cria saída SystemC
--stats Criar arquivo de estatísticas
--stats-vars Fornece estatísticas sobre variáveis
-sv Ativar análise SystemVerilog
+ systemverilogext + Sinônimo de + 1800-2012ext +
--top-module Nome do módulo de entrada de nível superior
--trace Habilita a criação da forma de onda
--trace-depth Profundidade de rastreamento
--trace-max-array Largura máxima de bits para rastreamento
--trace-max-width Profundidade máxima da matriz para rastreamento
--trace-params Ativa parâmetros de rastreamento
--trace-structs Ativa nomes de estruturas de rastreamento
--trace-underscore Habilita o rastreamento de _signals
-U Undefine pré-processador definir
--unroll-count Ajustar iterações máximas de loop
--unroll-stmts Ajustar o tamanho máximo do corpo do loop
--unused-regexp Sintonizar sinais de lint NÃO UTILIZADOS
-V versão detalhada e configuração
-v Biblioteca Verilog
+ verilog1995ext + Sinônimo de + 1364-1995ext +
+ verilog2001ext + Sinônimo de + 1364-2001ext +
-Werror- Converter aviso em erro
-Wfuture- Desativar avisos de mensagens desconhecidas
-Wno- Desativar aviso
-Wno-lint Desativa todos os avisos de lint
-Wno-style Desativa todos os avisos de estilo
-Wno-fatal Desativar saída fatal em avisos
--x-assign Inicialmente atribua Xs a este valor
--x-initial-edge Habilita os gatilhos iniciais de X-> 0 e X-> 1
-y Diretório para pesquisar módulos

ARGUMENTOS

{arquivo.v}
Especifica o arquivo Verilog que contém o módulo superior a ser verificado.

{arquivo.c / .cc / .cpp / .cxx}
Especifica arquivos C ++ opcionais a serem vinculados ao código Verilog. Se algum arquivo C ++
são especificados desta forma, o Verilator incluirá uma regra de criação que gera um módulo
executável. Sem nenhum arquivo C ++, o Verilator irá parar no módulo__ALL.a biblioteca,
e presuma que você continuará vinculando com as regras do make que você mesmo escreve. Veja também o
Opção -CFLAGS.

{arquivo.a / .o / .so}
Especifica objetos opcionais ou arquivos de biblioteca a serem vinculados ao código Verilog, como um
abreviação para -LDFLAGS " ". Se algum arquivo for especificado desta forma, o Verilator
incluirá uma regra de criação que usa esses arquivos ao vincular o módulo executável.
Geralmente, isso só é útil quando usado com a opção --exe.

+ 1364-1995ext +ext
+ 1364-2001ext +ext
+ 1364-2005ext +ext
+ 1800-2005ext +ext
+ 1800-2009ext +ext
+ 1800-2012ext +ext
Especifica o padrão de idioma a ser usado com uma extensão de nome de arquivo específica, ext.

Para compatibilidade com outros simuladores, consulte também os sinônimos "+ verilog1995ext +"ext,
"+ verilog2001ext +"exte "+ systemverilogext +"ext.

Para qualquer arquivo de origem, o idioma especificado por essas opções tem precedência sobre qualquer
idioma especificado pelas opções "--default-language" ou "--language".

Essas opções entram em vigor na ordem em que são encontradas. Assim, o seguinte seria
use Verilog 1995 para "av" e Verilog 2001 para "bv".

verilator ... + 1364-1995ext + v av + 1364-2001ext + v bv

Essas sinalizações são recomendadas apenas para designs legados de idiomas mistos, como o preferível
opção é editar o código para reparar novas palavras-chave ou adicionar
"` begin_keywords ".

Note "` begin_keywords "é uma construção SystemVerilog, que especifica só qual o
conjunto de palavras-chave deve ser reconhecido. Qualquer que seja o conjunto escolhido, a semântica será
aqueles de SystemVerilog. Em contraste, "+ 1364-1995ext +" etc. especifique a sintaxe e
semântica a ser usada.

--afirmar
Habilite todas as asserções.

Veja também --x-assign e --x-initial-edge; configuração "--x-atribuir exclusivo" e / ou
"--x-initial-edge" pode ser desejável.

--autoflush
Após cada $ display ou $ fdisplay, libere o fluxo de saída. Isso garante que
as mensagens aparecerão imediatamente, mas podem reduzir o desempenho; para melhor desempenho, ligue
"fflush (stdout)" ocasionalmente no loop C principal. Padrões desativados, o que armazenará em buffer
saída fornecida pelas chamadas C stdio normais.

--bbox-sys
Caixa preta qualquer tarefa $ sistema ou chamada de função desconhecida. As tarefas do sistema serão simplesmente
NOPed e as funções do sistema serão substituídas por zero não dimensionado. Argumentos para tal
as funções serão analisadas, mas não verificadas de outra forma. Isso evita erros quando
linting na presença de chamadas PLI específicas da empresa.

--bbox-unsup
Caixa preta com alguns recursos de linguagem não suportados, atualmente tabelas UDP e o CMOS e
primitivas tran gate. Isso pode permitir que o resto do design seja aplicado, mesmo quando
construções não suportadas estão presentes.

--bin nome do arquivo
Raramente necessário. Substitua o nome de arquivo padrão do próprio Verilator. Quando uma dependência
(.d) arquivo é criado, este nome de arquivo se tornará uma dependência de origem, de modo que um
a mudança neste binário terá que reconstruir os arquivos de saída.

-CFLAGS bandeiras
Adicione sinalizadores de compilador C especificados aos makefiles gerados. Quando o make é executado no
makefile gerado será passado para o compilador C ++ (gcc / g ++ / msvc ++).

--cc
Especifica C ++ sem modo de saída SystemC; veja também --sc.

--CDC
Experimental. Execute algumas verificações de cruzamento de domínio do relógio e emita avisos relacionados
(CDCRSTLOGIC) e, em seguida, saia; se outros avisos além dos avisos do CDC forem necessários, faça um
segunda execução com --lint-only. Informações adicionais de aviso também são escritas no
arquivo {prefixo} __ cdc.txt.

Atualmente verifica apenas alguns itens que outras ferramentas do CDC perderam; se você tem interesse em
adicionando mais cheques CDC tradicionais, entre em contato com os autores.

--clk nome-sinal
Às vezes, é bastante difícil para o Verilator distinguir os sinais do relógio de outros
sinais de dados. Ocasionalmente, os sinais do relógio podem acabar na lista de verificação de
sinais que determinam se avaliação adicional é necessária. Isso irá degradar fortemente
o desempenho do modelo verificado.

Com --clk , o usuário pode especificar o clock root no modelo, então o Verilator
irá marcar o sinal como clocker e propagar o atributo clocker automaticamente para
outros sinais derivados disso. Desta forma, o Verilator tentará evitar tomar o
sinal do clocker na lista de verificação.

Observe que o nome do sinal é especificado pelo caminho RTL hiearchy. Por exemplo, v.foo.bar. Se
o sinal é a entrada para o módulo superior, diretamente o nome do sinal. Se você encontrar
difícil encontrar o nome exato, tente usar "/ * verilator clocker * /" no arquivo RTL para
marque o sinal diretamente.

--compilador nome do compilador
Ativa ajustes e soluções alternativas para o compilador C ++ especificado.

retinir
Sintonize para clang. Isso pode reduzir a velocidade de execução, pois permite várias soluções alternativas
para evitar limites codificados bobos no clang. Isso inclui quebrar estruturas profundas
quanto ao msvc conforme descrito abaixo.

gcc Tune for Gnu C ++, embora o código gerado deva funcionar em quase qualquer C ++ compatível
compilador. Atualmente o padrão.

msvc
Ajuste para Microsoft Visual C ++. Isso pode reduzir a velocidade de execução, pois permite
várias soluções alternativas para evitar limites codificados bobos no MSVC ++. Isso inclui
quebrar expressões profundamente aninhadas entre parênteses em subexpressões para evitar
erro C1009 e divisão de blocos profundos em funções para evitar o erro C1061.

--converge-limit
Raramente necessário. Especifica o número máximo de iterações de tempo de execução antes de criar um
modelo não conseguiu convergir erro. O padrão é 100.

--cobertura
Ativa todas as formas de cobertura, alias para "--coverage-line --coverage-toggle
--coverage-user ".

--linha de cobertura
Especifica que o código de análise de cobertura de linha de bloqueio básico deve ser inserido.

A análise de cobertura adiciona declarações em cada ponto de mudança de fluxo de código, que são os
ramos das instruções IF e CASE, um superconjunto da cobertura de linha Verilog normal. No
em cada ramificação, um contador exclusivo é incrementado. No final de um teste, os contadores
junto com o nome do arquivo e o número da linha correspondente a cada contador são escritos em
logs / cobertura.pl.

O Verilator desativa automaticamente a cobertura de ramos que tenham $ stop neles, uma vez que
é assumido que os ramos $ stop contêm uma verificação de erro que não deve ocorrer. A / * verilator
cobertura_block_off * / comentário executará uma função semelhante em qualquer código nesse bloco
ou abaixo, ou / * o verilator cobertura_on / cobertura_off * / desabilitará a cobertura ao redor das linhas
de código.

Nota O Verilator pode sobrestimar blocos combinatórios (não cronometrados) quando esses blocos
receber sinais que tiveram o aviso UNOPTFLAT desativado; para mais preciso
os resultados não desabilitam este aviso ao usar cobertura.

--alternância de cobertura
Especifica que o código de análise de cobertura de alternância de sinal deve ser inserido.

Cada bit de cada sinal em um módulo tem um contador inserido. O contador vai
incremento em cada mudança de borda do bit correspondente.

Sinais que fazem parte de tarefas ou blocos de início / fim são considerados variáveis ​​locais e
não são cobertos. Sinais que começam com sublinhados, são inteiros ou são muito largos
(> Armazenamento total de 256 bits em todas as dimensões) também não são abrangidos.

A hierarquia é compactada, de modo que, se um módulo for instanciado várias vezes,
a cobertura será somada para esse bit em TODAS as instanciações desse módulo com o
mesmo conjunto de parâmetros. Um módulo instanciado com diferentes valores de parâmetro é
considerado um módulo diferente e será contado separadamente.

Verilator toma uma decisão minimamente inteligente sobre qual domínio de clock o sinal
vai para, e só procura arestas nesse domínio de relógio. Isso significa que as bordas podem ser
ignorado se for sabido que a borda nunca poderia ser vista pela lógica receptora. Esse
algoritmo pode melhorar no futuro. O resultado líquido é que a cobertura pode ser inferior a
o que seria visto ao olhar para os traços, mas a cobertura é mais precisa
representação da qualidade do estímulo no design.

Pode haver arestas contadas perto do tempo zero enquanto o modelo se estabiliza. É uma boa
prática para zerar toda a cobertura antes de liberar a redefinição para evitar a contagem de tais
comportamento.

Um par / * verilator verification_off / on * / comment pode ser usado em torno de sinais que não
precisa alternar a análise, como RAMs e arquivos de registro.

--cobertura-sublinhado
Habilite a cobertura de sinais que começam com um sublinhado. Normalmente, esses sinais são
não coberto. Veja também --trace-underscore.

--usuário de cobertura
Ativa a cobertura funcional inserida pelo usuário. Atualmente, todos os pontos de cobertura funcionais
são especificados usando SVA, que deve ser habilitado separadamente com --assert.

Por exemplo, a seguinte declaração adicionará um ponto de cobertura, com o comentário
"DefaultClock":

DefaultClock: propriedade da capa (@ (posedge clk) cyc == 3);

-Dvar=valor
Define o símbolo do pré-processador fornecido, sem permitir. Semelhante a + definir; + definir
é bastante padrão nas ferramentas Verilog, enquanto -D é um apelido para compatibilidade com GCC.

--depurar
Selecione a imagem de depuração construída do Verilator (se disponível) e habilite mais
asserções (equivalente a "--debug-check"), mensagens de depuração (equivalente a
"--debugi 4"), e arquivos de despejo de formato intermediário (equivalente a "--dump-treei 3").

--debug-check
Raramente necessário. Habilite verificações de asserção de depuração interna, sem alterar a depuração
verbosidade. Habilitado automaticamente quando --debug é especificado.

--debugi
--debugi-
Raramente necessário - para uso do desenvolvedor. Defina o nível de depuração interna globalmente para o
nível de depuração especificado (1-10) ou definir o arquivo de origem do Verilator especificado para o
nível especificado (por exemplo, "--debugi-V3Width 9"). Níveis mais altos produzem mais detalhes
mensagens.

--idioma padrão valor
Selecione o idioma a ser usado por padrão ao processar cada arquivo Verilog pela primeira vez.
O valor do idioma deve ser "1364-1995", "1364-2001", "1364-2005", "1800-2005",
"1800-2009" ou "1800-2012".

Qualquer idioma associado a uma extensão de arquivo específica (consulte os vários +langext +
opções) será usado em preferência ao idioma especificado por --default-language.

O sinalizador --default-language só é recomendado para código legado usando o mesmo
idioma em todos os arquivos de origem, pois a opção preferível é editar o código para reparar
novas palavras-chave ou adicione "` begin_keywords "apropriado. Para designs de idiomas mistos legados,
os vários +langdevem ser usadas opções ext +.

Se nenhum idioma for especificado, por este sinalizador ou +langext + options, então o mais recente
A linguagem SystemVerilog (IEEE 1800-2012) é usada.

+ definir +var=valor
+ definir +var=valor+var2=value2...
Define o símbolo do pré-processador fornecido ou vários símbolos se separados por sinais positivos.
Semelhante a -D; + define é bastante padrão nas ferramentas Verilog, enquanto -D é um alias
para compatibilidade com GCC.

- árvore de despejo
Raramente necessário. Habilite a gravação de arquivos de depuração .tree com nível de despejo 3, que despeja o
estágios críticos padrão. Para obter detalhes sobre o formato, consulte o Verilator Internals
manual. --dump-tree é habilitado automaticamente com --debug, então "--debug
--no-dump-tree "pode ​​ser útil se os arquivos de despejo forem grandes e indesejados.

--dump-treei
--dump-treei-
Raramente necessário - para uso do desenvolvedor. Defina o nível de despejo da árvore interna globalmente para um
nível de despejo específico ou definir o arquivo de origem do Verilator especificado para o
nível de despejo da árvore (por exemplo, "--dump-treei-V3Order 9"). O nível 0 desativa os dumps e é
equivalente a "--no-dump-tree". O nível 9 permite o despejo de todas as fases.

-E Pré-processa o código-fonte, mas não compila, como com 'gcc -E'. A saída é escrita
para padronizar. Cuidado ao habilitar mensagens de depuração, pois elas também irão para
padrão fora.

- limite de erro
Depois que esse número de erros ou avisos forem encontrados, saia. O padrão é 50.

--Exe
Gere um executável. Você também precisará passar arquivos .cpp adicionais no
linha de comando que implementa o loop principal para sua simulação.

-F lima
Leia o arquivo especificado e aja como se todo o texto dentro dele fosse especificado como comando
parâmetros de linha. Quaisquer caminhos relativos são relativos ao diretório que contém o
arquivo especificado. Consulte também -f. Observação -F é bastante padrão nas ferramentas Verilog.

-f lima
Leia o arquivo especificado e aja como se todo o texto dentro dele fosse especificado como comando
parâmetros de linha. Todos os caminhos relativos são relativos ao diretório atual. Veja também
-F. Observação -f é bastante padrão nas ferramentas Verilog.

O arquivo pode conter // comentários que são ignorados até o final da linha. Qualquer $ VAR,
$ (VAR) ou $ {VAR} será substituído pela variável de ambiente especificada.

--gdb
Execute o Verilator sob um GDB interativo (ou variável de ambiente VERILATOR_GDB
valor) sessão. Veja também --gdbbt.

--gdbbt
Se --debug for especificado, execute o Verilator sob um processo GDB e imprima um backtrace
na saída, saia do GDB imediatamente. Sem --debug ou se o GDB não parece funcionar,
este sinalizador é ignorado. Destina-se a fácil criação de backtraces pelos usuários; de outra forma
veja o sinalizador --gdb.

--Socorro
Exibe esta mensagem e a versão do programa e sai.

-Idir
Veja -y.

--if-profundidade valor
Raramente necessário. Defina a profundidade na qual o aviso IFDEPTH será disparado, o padrão é 0
que desativa este aviso.

+ incdir +dir
Veja -y.

--inibir sim
Raramente necessário. Crie uma função "inhibitSim (bool)" para habilitar e desabilitar a avaliação.
Isso permite que um testbench de nível superior desative os módulos que não são importantes em um
dada simulação, sem a necessidade de recompilar ou alterar os módulos SystemC
instanciado.

--inline-mult valor
Ajuste o inlining de módulos. O valor padrão de 2000 especifica que até 2000 novos
operações podem ser adicionadas ao modelo por inlining, se mais do que este número de
resultaria em operações, o módulo não é embutido. Valores maiores ou um valor <= 1
vai incorporar tudo, vai levar a tempos de compilação mais longos, mas potencialmente mais rápido
tempos de execução. Essa configuração é ignorada para módulos muito pequenos; eles sempre serão
inline, se permitido.

-LDFLAGS bandeiras
Adicionar sinalizadores de vinculador C especificados aos makefiles gerados. Quando o make é executado no
o makefile gerado será passado para o vinculador C ++ (ld) * após * o primário
arquivo sendo vinculado. Este sinalizador é chamado -LDFLAGS, pois esse é o nome tradicional em
simuladores; teria sido melhor chamado de LDLIBS, pois essa é a variável Makefile
ele controla. (Em Make, LDFLAGS está antes do primeiro objeto, LDLIBS depois. -L
as bibliotecas precisam estar no LDLIBS da variável Make, não no LDFLAGS.)

--língua valor
Um sinônimo para "--default-langauge", para compatibilidade com outras ferramentas e anteriores
versões do Verilator.

+ libext +ext+ext...
Especifique as extensões que devem ser usadas para localizar módulos. Se por exemplo módulo
x é referenciado, olhe em x.ext. Note + libext + é bastante padrão em Verilog
Ferramentas. O padrão é .v e .sv.

- apenas lint
Verifique os arquivos para violações de lint apenas, não crie nenhuma outra saída.

Você também pode querer a opção -Wall para habilitar mensagens que são consideradas estilísticas
e não habilitado por padrão.

Se o design não for completamente Verilado, veja também --bbox-sys e
Opções --bbox-unsup.

--MMD
Permite a criação de arquivos de dependência .d, usados ​​para fazer a detecção de dependência, semelhante a
Opção gcc -MMD. Ativado por padrão, use --no-MMD para desabilitar.

- MP
Ao criar arquivos de dependência .d com --MMD, faça alvos falsos. Semelhante a gcc -MP
opção.

--Mdir anuário
Especifica o nome do diretório Criar objeto. Todos os arquivos gerados serão colocados
neste diretório. Se não for especificado, "obj_dir" é usado. O diretório é criado se
ele não existe e os diretórios pais existem; caso contrário, crie manualmente o Mdir
antes de ligar para o Verilator.

--mod-prefixo nome principal
Especifica o nome a preceder a todas as classes de nível inferior. O padrão é o mesmo que
--prefixo.

--no-clk
Evita que o sinal especificado seja marcado como relógio. Veja "--clk".

--no-pins64
Alias ​​compatível com versões anteriores para "--pins-bv 33".

--não-pular-idêntico
Raramente necessário. Desativa a execução de pulo do Verilator se todos os arquivos de origem são
idênticos e todos os arquivos de saída existem com datas mais recentes.

+ notimingchecks
Ignorado para compatibilidade com outros simuladores.

-O0 Desativa a otimização do modelo.

-O3 Ativa otimizações lentas para o código que o próprio Verilator gera (ao contrário de
"-CFLAGS -O3" que efetua a otimização do compilador C. -O3 pode reduzir a simulação
tempos de execução ao custo do tempo de compilação. Isso atualmente define --inline-mult -1.

-Ocarta de otimização
Raramente necessário. Habilita ou desabilita otimizações específicas, com a otimização
selecionado com base na carta passada. Uma letra minúscula desativa uma otimização, um
a letra maiúscula permite isso. Destina-se apenas ao uso de depuração; veja a fonte
código para mapeamentos dependentes de versão de otimizações para letras -O.

-o
Especifique o nome do executável final criado se estiver usando --exe. Padrões para o
--prefix se não for especificado.

--no-order-clock-delay
Raramente necessário. Desativa a correção de um bug para a ativação do relógio com atraso
atribuições. Este sinalizador só deve ser usado quando sugerido pelos desenvolvedores.

--output-split bytes
Ativa a divisão dos arquivos .cpp / .sp de saída em várias saídas. Quando um arquivo C ++
excede o número especificado de operações, um novo arquivo será criado na próxima
limite de função. Além disso, quaisquer rotinas lentas serão colocadas em arquivos __Slow.
Isso acelera a compilação, pois a otimização pode ser desabilitada nas rotinas lentas,
e os arquivos restantes podem ser compilados em máquinas paralelas. Usando --output-split
deve ter apenas um impacto trivial no desempenho. Com GCC 3.3 em um Opteron de 2 GHz,
--output-split 20000 resultará na divisão em uma compilação de aproximadamente um minuto
pedaços.

--output-split-cfuncs declarações
Ativa funções de divisão nos arquivos .cpp / .sp de saída em várias funções.
Quando uma função gerada excede o número especificado de operações, uma nova função
Será criado. Com --output-split, isso permitirá que o GCC compile mais rápido, em um
pequena perda de desempenho que piora com a diminuição dos valores de divisão. Observe que
esta opção é mais forte do que --output-split no sentido de que --output-split não
dividido dentro de uma função.

--output-split-ctrace declarações
Ativa a divisão de funções de rastreio nos arquivos .cpp / .sp de saída em vários
funções. O padrão é a mesma configuração de --output-split-cfuncs.

-P Com -E, desativa a geração de marcadores de linha e linhas em branco, semelhante ao sinalizador GCC -P.

--pins64
Alias ​​compatível com versões anteriores para "--pins-bv 65". Observe que é um 65, não um 64.

--pins-bv largura
Especifica entradas / saídas SystemC maiores ou iguais a largura bits de largura devem
use sc_bv's em vez de uint32 / vluint64_t's. O padrão é "--pins-bv 65". Versões
antes do Verilator 3.671 padronizar para "--pins-bv 33". Quanto mais sc_bv for usado, pior
para desempenho. Use o atributo "/ * verilator sc_bv * /" para selecionar portas específicas para
seja sc_bv.

--pins-sc-uint
Especifica entradas / saídas SystemC maiores que 2 bits de largura devem usar sc_uint
entre 2 e 64. Quando combinado com a combinação "--pins-sc-biguint", resulta
em sc_uint sendo usado entre 2 e 64 e sc_biguint sendo usado entre 65 e 512.

--pins-sc-biguint
Especifica entradas / saídas SystemC maiores que 65 bits de largura devem usar sc_biguint
entre 65 e 512 e sc_bv de 513 para cima. Quando combinado com o
Combinação "--pins-sc-uint", resulta em sc_uint sendo usado entre 2 e 64 e
sc_biguint sendo usado entre 65 e 512.

--pins-uint8
Especifica entradas / saídas SystemC que são menores do que a configuração --pins-bv e 8
bits ou menos devem usar uint8_t em vez de uint32_t. Da mesma forma, os pinos de largura 9-16 irão
use uint16_t em vez de uint32_t.

--pipe-filtro comando
Raramente necessário e experimental. Verilator irá gerar o comando especificado como um
tubo de subprocesso, para permitir que o comando execute edições personalizadas no código Verilog
antes de chegar ao Verilator.

Antes de ler cada arquivo Verilog, o Verilator passará o nome do arquivo para o subprocesso '
stdin com 'read_verilog " "'. O filtro pode então ler o arquivo e executar
qualquer filtragem que desejar e alimenta o novo conteúdo do arquivo de volta para o Verilator em stdout
com 'Content-Length'. Saída para stderr do filtro alimenta para o Verilator
stdout e se o filtro sair com status diferente de zero, o Verilator termina. Veja o
teste t / t_pipe_filter para um exemplo.

Para depurar a saída do filtro, tente usar a opção -E para ver a saída pré-processada.

--prefixo nome principal
Especifica o nome da classe de nível superior e makefile. O padrão é V prefixado a
o nome do switch --top-module, ou V prefixado ao primeiro nome de arquivo Verilog
passado na linha de comando.

--profile-cfuncs
Modifique as funções C ++ criadas para oferecer suporte à criação de perfil. As funções serão
minimizado para conter uma instrução "básica", geralmente um único bloco always ou wire
demonstração. (Observe que isso tornará o executável mais lento em cerca de 5%.) Além disso, o
o nome da função será sufixado com o nome de base do módulo Verilog e o número da linha
a declaração veio. Isso permite que relatórios gprof ou oprofile sejam correlacionados com
as declarações originais da fonte Verilog.

--privado
Oposto de --public. É o padrão; esta opção existe para compatibilidade com versões anteriores.

--público
Isso é apenas para uso de depuração histórica. Usá-lo pode resultar em simulação incorreta de
relógios gerados.

Declara todos os sinais e módulos públicos. Isso desligará as otimizações de sinal como
se todos os sinais tivessem um / * verilator public * / comments e inlining. Isso também vai virar
desativado inlining como se todos os módulos tivessem um / * verilator public_module * /, a menos que o módulo
especificamente habilitado com / * verilator inline_module */.

--report-unopflat
Diagnósticos extras para avisos UNOPTFLAT. Isso inclui para cada loop, os 10 mais largos
variáveis ​​no loop e as 10 variáveis ​​mais distribuídas no loop. Estes são
candidatos para divisão em várias variáveis ​​para quebrar o loop.

Além disso, produz um arquivo GraphViz DOT de todos os componentes fortemente conectados
dentro da fonte associada a cada loop. Isso é produzido independentemente de
--dump-tree está definido. Esses gráficos podem ajudar na análise do problema, mas podem ser muito
grande, de fato.

Existem vários comandos para visualizar e manipular arquivos DOT. Por exemplo o ponto
O comando pode ser usado para converter um arquivo DOT em PDF para impressão. Por exemplo:

ponto -Tpdf -O Vt_unoptflat_simple_2_35_unoptflat.dot

irá gerar um PDF Vt_unoptflat_simple_2_35_unoptflat.dot.pdf a partir do arquivo DOT.

--salvável
Habilite a inclusão de funções de salvar e restaurar no modelo gerado.

O código do usuário deve criar um objeto VerilatedSerialize ou VerilatedDeserialze e então
chamar os operadores << ou >> no modelo gerado e quaisquer outros dados do processo
precisa ser salvo / restaurado. Por exemplo:

void save_model (const char * filenamep) {
VerilatedSalvar os;
os.open (nome do arquivop);
os << main_time; // o código do usuário deve salvar o carimbo de data / hora, etc.
os << * topp;
}
void restore_model (const char * filenamep) {
VerilatedRestore os;
os.open (nome do arquivop);
os >> main_time;
os >> * topp;
}

--sc
Especifica o modo de saída SystemC; veja também --cc.

--Estatísticas
Cria um arquivo de despejo com estatísticas sobre o design em {prefix} __ stats.txt.

--stats-vars
Cria estatísticas mais detalhadas incluindo uma lista de todas as variáveis ​​por tamanho (simples
--stats apenas dá uma contagem). Veja --stats, o que está implícito nisso.

-sv Especifica que os recursos de idioma SystemVerilog devem ser ativados; equivalente a "--language
1800-2005 ". Esta opção é selecionada por padrão, existe para compatibilidade com
outros simuladores.

+ systemverilogext +ext
Um sinônimo para "+ 1800-2012ext +"ext.

--módulo superior nome principal
Quando a entrada Verilog contém mais de um módulo de nível superior, especifica o nome do
o módulo Verilog de nível superior para se tornar o superior e define o padrão para if --prefix
não é usado. Isso não é necessário com designs padrão com apenas uma parte superior.

--vestígio
Adiciona código de rastreamento de forma de onda ao modelo. Verilator irá gerar
{prefixo} __ Rastreia arquivos * .cpp que precisarão ser compilados. Além disso
verilated_vcd_sc.cpp (para rastreamentos SystemC) ou verilated_vcd_c.cpp (para ambos) deve ser
compilado e vinculado. Se usar os Makefiles gerados pelo Verilator, eles serão
adicionado como destino de origem para você. Se você não estiver usando os makefiles do Verilator, você
precisará adicioná-los ao seu Makefile manualmente.

Ter o rastreamento compilado pode resultar em algumas pequenas perdas de desempenho, mesmo quando
formas de onda não são ativadas durante a execução do modelo.

--trace-profundidade níveis
Especifique o número de níveis de profundidade para habilitar o rastreamento, por exemplo --trace-level 1 para
ver apenas os sinais do nível superior. O padrão é todo o modelo. Usando um pequeno número
diminuirá a visibilidade, mas melhorará muito o tempo de execução e o tamanho do arquivo de rastreamento.

--trace-max-array profundidade
Raramente necessário. Especifique a profundidade máxima da matriz de um sinal que pode ser rastreado.
O padrão é 32, pois o rastreamento de grandes matrizes pode tornar as simulações rastreadas muito lentas.

--trace-max-largura largura
Raramente necessário. Especifique a largura máxima de bits de um sinal que pode ser rastreado.
O padrão é 256, pois o rastreamento de vetores grandes pode tornar as simulações de rastreamento muito lentas.

--no-trace-params
Desative o rastreamento de parâmetros.

--trace-structs
Ative o rastreio para mostrar o nome da estrutura empacotada, união e campos de matriz empacotada,
em vez de um ônibus compactado combinado simgle. Devido às restrições de formato de arquivo VCD, isso pode
resultam em tempos de rastreamento significativamente mais lentos e arquivos de rastreamento maiores.

--trace-sublinhado
Ative o rastreamento de sinais que começam com um sublinhado. Normalmente, esses sinais são
não sai durante o rastreamento. Veja também --coverage-underscore.

-Uvar
Indefine o símbolo do pré-processador fornecido.

--unroll-count laços
Raramente necessário. Especifica o número máximo de iterações de loop que podem ser desenroladas.
Veja também o aviso BLKLOOPINIT.

--unroll-stmts declarações
Raramente necessário. Especifica o número máximo de instruções em um loop para esse loop para
ser desenrolado. Veja também o aviso BLKLOOPINIT.

--unused-regexp regexp
Raramente necessário. Especifica uma regexp simples com * e? que se um nome de sinal corresponder
irá suprimir o aviso NÃO UTILIZADO. O padrão é "* não utilizado *". Definir como "" desativa
Coincidindo.

-V Mostra a versão detalhada, incluindo informações de configuração compiladas em
Verilator. (Semelhante a perl -V.)

-v nome do arquivo
Leia o nome do arquivo como uma biblioteca Verilog. Quaisquer módulos no arquivo podem ser usados ​​para
resolver instanciações de células no módulo de nível superior, caso contrário, será ignorado. Observe que -v é bastante
padrão nas ferramentas Verilog.

+ verilog1995ext +ext
+ verilog2001ext +ext
Sinônimos para "+ 1364-1995ext +"ext e "+ 1364-2001ext +"ext respectivamente

-Parede
Habilite todos os avisos, incluindo avisos de estilo de código que normalmente são desabilitados por
padrão.

-Erro-mensagem
Converta a mensagem de aviso especificada em uma mensagem de erro. Isso geralmente é para
desencorajar os usuários de violar regras importantes para todo o site, por exemplo
"-Werror-NOUNOPTFLAT".

-Wfuturo-mensagem
Raramente necessário. Suprima comentários desconhecidos do Verilator ou mensagens de aviso com o dado
código da mensagem. Isso é usado para permitir o código escrito com pragmas para uma versão posterior do
Verilator para rodar em uma versão mais antiga; adicionar argumentos -Wfuture- para cada código de mensagem
ou comente que a nova versão é compatível, a qual não é compatível com a versão anterior.

-Não-mensagem
Desative a mensagem de aviso especificada. Isso substituirá quaisquer diretivas lint_on em
a fonte, ou seja, o aviso ainda não será impresso.

-Sem fiapos
Desative todas as mensagens de aviso relacionadas ao lint e todos os avisos de estilo. Isso é equivalente
para "-Wno-ALWCOMBORDER -Wno-CASEINCOMPLETE -Wno-CASEOVERLAP -Wno-CASEX -Wno-CASEWITHX
-Wno-CMPCONST -Wno-ENDLABEL -Wno-IMPLICIT -Wno-LITENDIAN -Wno-PINCONNECTEMPTY
-Wno-PINMISSING -Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED -Wno-WIDTH "
mais a lista mostrada para o estilo Wno.

É altamente recomendável que você limpe seu código em vez de usar esta opção, é
destina-se apenas a ser usado ao executar casos de teste de código recebido de terceiros.

-Estilo sem graça
Desabilite todas as mensagens de aviso relacionadas ao estilo de código (observe que por padrão elas já estão
Desativado). Isso é equivalente a "-Wno-DECLFILENAME -Wno-DEFPARAM -Wno-INCABSPATH
-Wno-PINCONNECTEMPTY -Wno-PINNOCONNECT -Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNUSED
-Wno-VARHIDDEN ".

-Não-fatal
Quando os avisos forem detectados, imprima-os, mas não saia do simulador.

Ter mensagens de advertência em compilações é desleixado. É altamente recomendável que você limpe
seu código, use lint_off embutido ou use sinalizadores -Wno -... em vez de usar esta opção.

-Wavisar-mensagem
Ativa a mensagem de aviso especificada.

-Wwarn-lint
Habilite todas as mensagens de aviso relacionadas ao lint (observe que por padrão elas já estão habilitadas),
mas não afeta as mensagens de estilo. Isso é equivalente a "-Wwarn-ALWCOMBORDER
-Wwarn-CASEINCOMPLETE -Wwarn-CASEOVERLAP -Wwarn-CASEX -Wwarn-CASEWITHX -Wwarn-CMPCONST
-Wwarn-ENDLABEL -Wwarn-IMPLICIT -Wwarn-LITENDIAN -Wwarn-PINMISSING -Wwarn-REALCVT
-Wwarn-UNSIGNED -Wwarn-WIDTH ".

-Estilo Wwarn
Habilite todas as mensagens de aviso relacionadas ao estilo de código. Isso é equivalente a "-Wwarn
ATRIBUIR -Wwarn-DECLFILENAME -Wwarn-DEFPARAM -Wwarn-INCABSPATH -Wwarn-PINNOCONNECT
-Wwarn-SYNCASYNCNET -Wwarn-UNDRIVEN -Wwarn-UNUSED -Wwarn-VARHIDDEN ".

--x-atribuir 0
--x-atribuir 1
--x-assign fast (padrão)
--x-assign exclusivo
Controla o valor de dois estados que é substituído quando uma atribuição para X é encontrada.
--x-assign = fast, o padrão, converte todos os Xs para o que for melhor para o desempenho.
--x-assign = 0 converte todos os Xs em 0s e também é rápido. --x-assign = 1 converte todos os Xs para
1s, isso é quase tão rápido quanto 0, mas é mais provável que encontre bugs de redefinição como ativo alto
a lógica vai disparar. --x-assign = unique irá chamar uma função para determinar o valor, este
permite a randomização de todos os Xs para encontrar bugs de redefinição e é o mais lento, mas o mais seguro para
encontrar bugs de redefinição no código.

Se estiver usando --x-assign unique, você pode querer semear o seu gerador de números aleatórios como
que cada execução de regressão obtém uma sequência de randomização diferente. Use o sistema
srand48 () ou para Windows srand () função para fazer isso. Você provavelmente também vai querer
imprima quaisquer sementes selecionadas e codifique para permitir a reexecução com a mesma semente para que você possa
reproduzir bugs.

Notas. Esta opção se aplica apenas a variáveis ​​que são explicitamente atribuídas a X no
Código-fonte Verilog. Os valores iniciais dos relógios são definidos como 0, a menos que --x-initial-edge seja
Especificadas. Os valores iniciais de todas as outras variáveis ​​de manutenção de estado são definidos como se
--x-assign exclusivo foi especificado.

--x-borda inicial
Permite a emulação de simuladores orientados a eventos que geralmente acionam uma borda em um
transição de X para 1 ("posedge") ou X para 0 ("negedge"). Assim, o código a seguir,
onde "rst_n" não foi inicializado, definiria "res_n" para "1'b1" quando "rst_n" for definido pela primeira vez
para zero:

reg res_n = 1'b0;

sempre @ (negedge rst_n) começar
if (rst_n == 1'b0) começar
res_n <= 1'b1;
final
final

No Verilator, por padrão, os relógios não inicializados recebem o valor zero, então o acima
o bloco "sempre" não seria acionado.

Embora não seja uma boa prática, existem alguns projetos que dependem de XX 0 acionando um
"negedge", particularmente em sequências de reinicialização. Usar --x-initial-edge com Verilator irá
replicar esse comportamento. Isso também irá garantir que XX 1 acione um "posedge".

Notas. Alguns usuários relataram que o uso desta opção pode afetar a convergência, e que
pode ser necessário usar --converge-limit para aumentar o número de convergência
iterações. Isso pode ser outra indicação de problemas com o design modelado que
devem ser abordadas.

-y dir
Adicione o diretório à lista de diretórios que devem ser pesquisados ​​para incluir arquivos
ou bibliotecas. Os três sinalizadores -y, + incdir e -I têm efeito semelhante; + incdir e + y
são razoavelmente padrão nas ferramentas Verilog, enquanto -I é um apelido para compatibilidade com GCC.

O Verilator assume como padrão o diretório atual ("-y.") E qualquer --Mdir especificado, embora
esses caminhos padrão são usados ​​após quaisquer diretórios especificados pelo usuário. Isso permite '-y
"$ (pwd)" 'a ser usado se nomes de arquivo absolutos forem desejados para mensagens de erro em vez de
nomes de arquivos relativos.

EXEMPLO C + + EXECUÇÃO

Vamos compilar este exemplo em C ++.

mkdir teste_nosso
cd teste_nosso

gato < our.v
módulo nosso;
início inicial $ display ("Hello World"); $ terminar; fim
endmodule
EOF

gato < sim_main.cpp
#include "Vour.h"
#include "verilated.h"
int main (int argc, char ** argv, char ** env) {
Verilated :: commandArgs (argc, argv);
Vour * topo = novo Vour;
while (! Verilated :: gotFinish ()) {top-> eval (); }
excluir topo;
saída(0);
}
EOF

Se você instalou o Verilator a partir de fontes ou um tarball, mas não como parte de sua operação
sistema (como um RPM), primeiro você precisa apontar para o kit:

exportar VERILATOR_ROOT = / caminho / para / onde / verilator / foi / instalado
exportar PATH = $ VERILATOR_ROOT / bin: $ PATH

Agora rodamos o Verilator em nosso pequeno exemplo.

verilator -Wall --cc our.v --exe sim_main.cpp

Podemos ver o código-fonte no diretório "obj_dir". Consulte a seção ARQUIVOS abaixo para
descrições de alguns dos arquivos que foram criados.

ls -l obj_dir

Podemos então compilá-lo

cd obj_dir
make -j -f Vour.mk Vour

(Verilator incluiu uma regra de compilação padrão e regra de link, uma vez que usamos --exe e passamos um
arquivo .cpp na linha de comando do Verilator. Você também pode escrever suas próprias regras de compilação, como
vamos mostrar na seção SYSTEMC.)

E agora nós o executamos

cd ..
obj_dir / Vour

E obtemos como saída

Olá Mundo
- our.v: 2: acabamento em Verilog $

Realmente, é melhor você escrever um Makefile para fazer tudo isso por você. Então, quando o seu
alterações de origem, ele executará automaticamente todas essas etapas. Veja o diretório test_c em
a distribuição para um exemplo.

EXEMPLO SISTEMA EXECUÇÃO

Este é um exemplo semelhante ao anterior, mas usando SystemC.

mkdir test_our_sc
cd teste_nosso_sc

gato < our.v
módulo nosso (clk);
input clk; // O relógio é necessário para obter a ativação inicial
sempre @ (clk posedge)
begin $ display ("Hello World"); $ terminar; fim
endmodule
EOF

gato < sc_main.cpp
#include "Vour.h"
int sc_main (int argc, char ** argv) {
Verilated :: commandArgs (argc, argv);
sc_clock clk ("clk", 10, 0.5, 3, verdadeiro);
Vour * top;
topo = novo Vour ("topo"); // SP_CELL (topo, Vour);
top-> clk (clk); // SP_PIN (topo, clk, clk);
while (! Verilated :: gotFinish ()) {sc_start (1, SC_NS); }
excluir topo;
saída(0);
}
EOF

Se você instalou o Verilator a partir de fontes ou um tarball, mas não como parte de sua operação
sistema (como um RPM), primeiro você precisa apontar para o kit:

exportar VERILATOR_ROOT = / caminho / para / onde / verilator / foi / instalado
exportar PATH = $ VERILATOR_ROOT / bin: $ PATH

Agora rodamos o Verilator em nosso pequeno exemplo.

verilator -Wall --sc nosso.v

Podemos então compilá-lo

make -j -f Vour.mk Vour__ALL.a
make -j -f Vour.mk ../sc_main.o verilated.o

E conecte-se com SystemC. Observe que o seu caminho para as bibliotecas pode variar, dependendo do
sistema operacional.

exportar SYSTEMC_LIBDIR = / caminho / para / onde / libsystemc.a / existe
exportar LD_LIBRARY_PATH = $ SYSTEMC_LIBDIR: $ LD_LIBRARY_PATH
# Pode ser necessário se SystemC 2.3.0
export SYSTEMC_CXX_FLAGS = -pthread

g ++ -L $ SYSTEMC_LIBDIR ../sc_main.o Vour__ALL * .o verilated.o \
-o Vour -lsystemc

E agora nós o executamos

cd ..
obj_dir / Vour

E obtemos a mesma saída do exemplo C ++:

Olá Mundo
- our.v: 2: acabamento em Verilog $

Realmente, é melhor você usar um Makefile para fazer tudo isso por você. Então, quando sua fonte
alterações, ele executará automaticamente todas essas etapas. Veja o diretório test_sc no
distribuição para um exemplo.

AVALIAÇÃO COMPARATIVA & OTIMIZAÇÃO

Para obter o melhor desempenho, execute o Verilator com os sinalizadores "-O3 --x-assign = fast --noassert". o
-O3 sinalizador exigirá tempos de compilação mais longos, e --x-assign = fast pode aumentar o risco de
redefinir bugs no comércio para desempenho; consulte a documentação acima para esses sinalizadores.

Pequenas alterações no código Verilog também podem gerar grandes ganhos. Você não deve ter nenhum UNOPTFLAT
avisos do Verilator. Corrigir esses avisos pode resultar em grandes melhorias; um usuário
consertou seu único aviso UNOPTFLAT fazendo uma simples mudança em uma trava de relógio usada para bloquear
relógios e ganhou uma melhoria de desempenho de 60%.

Além disso, o desempenho de um modelo Verilated depende principalmente do seu compilador C ++ e
tamanho dos caches de sua CPU.

Por padrão, o arquivo lib / verilated.mk tem a otimização desativada. Isto é para o
benefício de novos usuários, pois melhora os tempos de compilação às custas dos tempos de execução. Adicionar
otimização como padrão, defina uma das três variáveis, OPT, OPT_FAST ou OPT_SLOW
lib / verilated.mk. Ou use a opção -CFLAGS e / ou -LDFLAGS no comando verilator
linha para passar os sinalizadores diretamente para o compilador ou vinculador. Ou, apenas para uma corrida, passe
eles na linha de comando para fazer:

make OPT_FAST = "- O2" -f Vour.mk Vour__ALL.a

OPT_FAST especifica otimizações para os programas que fazem parte do caminho rápido, principalmente
código que é executado a cada ciclo. OPT_SLOW especifica otimizações para arquivos de caminho lento
(mais rastreamento), que são executados apenas raramente, mas levam muito tempo para compilar com
otimização ativada. OPT especifica a otimização geral e afeta todas as compilações, incluindo
aqueles OPT_FAST e OPT_SLOW afetam. Para obter melhores resultados, use OPT = "- O2" e vincule com
"-estático". Quase os mesmos resultados podem ser obtidos com tempos de compilação muito melhores com
OPT_FAST = "- O1 -fstrict-aliasing". Otimização superior, como "-O3" pode ajudar, mas gcc
os tempos de compilação podem ser excessivos em O3, mesmo em designs de tamanho médio. Alternativamente, alguns
projetos maiores relatam melhor desempenho usando "-Os".

Infelizmente, usar o otimizador com arquivos SystemC pode resultar em compilações
muitos minutos. (As bibliotecas SystemC têm muitas pequenas funções embutidas que conduzem o
nozes do compilador.)

Para obter melhores resultados, use o GCC 3.3 ou mais recente. O GCC 3.2 e anteriores apresentam bugs de otimização
detecção de aliasing de ponteiro, que pode resultar em 2x perdas de desempenho.

Se você for executar muitas simulações em uma única compilação, investigue o feedback orientado
compilação. Com o GCC, usando -fprofile-arcs, então -fbranch-probabilities renderá
outros 15% ou mais.

Compiladores modernos também suportam otimização de tempo de ligação (LTO), o que pode ajudar especialmente se
você vincula no código DPI. Para habilitar o LTO no GCC, passe "-flto" na compilação e no link.
Observação LTO pode causar tempos de compilação excessivos em projetos grandes.

Se você estiver usando seus próprios makefiles, você pode querer compilar o código Verilated com
-DVL_INLINE_OPT = embutido. Isso irá incorporar funções, no entanto, isso requer que todos os cpp
os arquivos sejam compilados em uma única execução do compilador.

Você pode descobrir outras possibilidades de ajuste definindo o perfil do código Verilog. Usar
--Profile-cfuncs do Verilator, depois -g -pg do GCC. Você pode então executar o oprofile ou
gprof para ver onde o tempo é gasto no código C ++. Execute a saída do gprof por meio de
verilator_profcfunc e ele dirá quais números de linha Verilog em que a maioria dos
o tempo está sendo gasto.

Quando terminar, informe o autor dos resultados. Gosto de acompanhar como o Verilator
compara e pode sugerir melhorias adicionais.

Use verilator online usando serviços onworks.net