SystemVerilog - SystemVerilog

SystemVerilog
SystemVerilog logo.png
Logotipo SystemVerilog
Paradigma Estruturado (design)
Orientado a objetos (verificação)
Projetado por Sinopse , mais tarde IEEE
Apareceu pela primeira vez 2002 ; 19 anos atras ( 2002 )
Versão estável
IEEE 1800-2017 / 22 de fevereiro de 2018 ; 3 anos atrás ( 22/02/2018 )
Disciplina de digitação Estático , fraco
Extensões de nome de arquivo .sv, .svh
Influenciado por
Design: Verilog , VHDL , C ++ , Verificação: OpenVera , Java

SystemVerilog , padronizado como IEEE 1800 , é uma descrição de hardware e linguagem de verificação de hardware usada para modelar, projetar , simular , testar e implementar sistemas eletrônicos. SystemVerilog é baseado em Verilog e algumas extensões, e desde 2008 Verilog agora faz parte do mesmo padrão IEEE . É comumente usado na indústria de semicondutores e design eletrônico como uma evolução do Verilog.

História

SystemVerilog começou com a doação da linguagem Superlog para a Accellera em 2002 pela empresa startup Co-Design Automation. A maior parte da funcionalidade de verificação é baseada na linguagem OpenVera doada pela Synopsys . Em 2005, o SystemVerilog foi adotado como o padrão IEEE 1800-2005. Em 2009, o padrão foi fundido com o padrão básico Verilog (IEEE 1364-2005), criando o padrão IEEE 1800-2009. A versão atual é o padrão IEEE 1800-2017.

O conjunto de recursos de SystemVerilog pode ser dividido em duas funções distintas:

  1. SystemVerilog para projeto de nível de transferência de registro (RTL) é uma extensão do Verilog-2005 ; todos os recursos desse idioma estão disponíveis em SystemVerilog. Portanto, Verilog é um subconjunto de SystemVerilog.
  2. SystemVerilog para verificação usa extensas técnicas de programação orientada a objetos e está mais relacionado a Java do que Verilog. Essas construções geralmente não são sintetizáveis.

O restante deste artigo discute os recursos do SystemVerilog não presentes no Verilog-2005 .

Características de design

Vida útil dos dados

Existem dois tipos de vida útil de dados especificados em SystemVerilog: estático e automático . Variáveis ​​automáticas são criadas no momento em que a execução do programa chega ao escopo da variável. Variáveis ​​estáticas são criadas no início da execução do programa e mantêm o mesmo valor durante toda a vida útil do programa, a menos que seja atribuído um novo valor durante a execução.

Qualquer variável declarada dentro de uma tarefa ou função sem especificar o tipo será considerada automática. Para especificar que uma variável é estática, coloque a palavra-chave " static" na declaração antes do tipo, por exemplo, " ". A palavra-chave " " é usada da mesma maneira. static int x;automatic

Novos tipos de dados

Tipos de variáveis ​​aprimorados adicionam nova capacidade ao tipo "reg" da Verilog: 

logic [31:0] my_var;

Verilog-1995 e -2001 limitam variáveis ​​reg para declarações comportamentais, como código RTL . SystemVerilog estende o tipo de reg para que ele possa ser conduzido por um único driver, como portão ou módulo. SystemVerilog nomeia esse tipo de "lógica" para lembrar aos usuários que ele tem esse recurso extra e não é um registro de hardware. Os nomes "lógico" e "reg" são intercambiáveis. Um sinal com mais de um driver (como um buffer tri-state para entrada / saída de propósito geral ) precisa ser declarado como um tipo de rede, como "fio" para que SystemVerilog possa resolver o valor final.

Arrays empacotados multidimensionais unificam e estendem a noção de "registros" e "memórias" da Verilog: 

logic [1:0][2:0] my_pack[32];

O Verilog clássico permitia que apenas uma dimensão fosse declarada à esquerda do nome da variável. SystemVerilog permite qualquer número de dimensões "compactadas". Uma variável do tipo array empacotado mapeia 1: 1 em uma quantidade aritmética inteira. No exemplo acima, cada elemento de my_packpode ser usado em expressões como um número inteiro de seis bits. As dimensões à direita do nome (32 neste caso) são referidas como dimensões "desempacotadas". Como em Verilog-2001 , qualquer número de dimensões não embaladas é permitido.

Os tipos de dados enumerados (enums) permitem que quantidades numéricas recebam nomes significativos. As variáveis ​​declaradas como do tipo enumerado não podem ser atribuídas a variáveis ​​de um tipo enumerado diferente sem conversão . Isso não é verdade para os parâmetros, que eram a técnica de implementação preferida para quantidades enumeradas em Verilog-2005: 

typedef enum logic [2:0] {
   RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW
} color_t;

color_t   my_color = GREEN;
initial $display("The color is %s", my_color.name());

Conforme mostrado acima, o designer pode especificar um tipo aritmético subjacente ( logic [2:0]neste caso) que é usado para representar o valor de enumeração. Os meta-valores X e Z podem ser usados ​​aqui, possivelmente para representar estados ilegais. A função name()interna retorna uma string ASCII para o valor enumerado atual, que é útil na validação e teste.

Novos tipos inteiros : define SystemVerilog byte, shortint, inte longintcomo de dois estados tipos integrais assinados com 8, 16, 32, e 64 bits, respectivamente. Um bittipo é um tipo de dois estados de largura variável que funciona de forma semelhante logic. Os tipos de dois estados não possuem os metavalores X e Z do Verilog clássico; trabalhar com esses tipos pode resultar em uma simulação mais rápida.

Estruturas e os sindicatos funcionam como eles fazem na linguagem de programação C . Os aprimoramentos de SystemVerilog incluem oatributo compactado e oatributo marcado . Otaggedatributo permite o rastreamento em tempo de execução de quais membros de um sindicato estão atualmente em uso. Opackedatributo faz com que a estrutura ou união seja mapeada 1: 1 em uma matriz compactada de bits. O conteúdo dosstructtiposdedados ocupa um bloco contínuo de memória sem lacunas, semelhante aos campos de bits em C e C ++: 

typedef struct packed {
    bit [10:0]  expo;
    bit         sign;
    bit [51:0]  mant;
} FP;

FP     zero = 64'b0;

Conforme mostrado neste exemplo, SystemVerilog também oferece suporte a typedefs , como em C e C ++.

Bloqueios procedimentais

SystemVerilog apresenta três novos blocos procedurais destinados a modelar hardware : always_comb(para modelar lógica combinacional ), always_ff(para flip-flops ) e always_latch(para travas ). Considerando que a Verilog usou um único alwaysbloco de propósito geral para modelar diferentes tipos de estruturas de hardware, cada um dos novos blocos do SystemVerilog se destina a modelar um tipo específico de hardware, impondo restrições semânticas para garantir que o hardware descrito pelos blocos corresponda ao uso pretendido de o modelo. Um compilador HDL ou programa de verificação pode realizar etapas extras para garantir que apenas o tipo de comportamento pretendido ocorra.

Um always_combbloco modela a lógica combinacional . O simulador infere que a lista de sensibilidade contém todas as variáveis ​​das declarações contidas: 

always_comb begin
    tmp = b * b - 4 * a * c;
    no_root = (tmp < 0);
end

Um always_latchbloco modela travas sensíveis ao nível . Novamente, a lista de sensibilidade é inferida do código: 

always_latch
    if (en) q <= d;

Um always_ffbloco modela a lógica síncrona (especialmente a lógica sequencial sensível à borda ): 

always_ff @(posedge clk)
    count <= count + 1;

As ferramentas de automação de projeto eletrônico (EDA) podem verificar a intenção do projeto, verificando se o modelo de hardware não viola nenhuma semântica de uso de bloco. Por exemplo, os novos blocos restringem a atribuição a uma variável permitindo apenas uma fonte, enquanto o alwaysbloco de Verilog permite a atribuição de várias fontes procedurais.

Interfaces

Para projetos pequenos, a porta Verilog descreve de forma compacta a conectividade de um módulo com o ambiente circundante. Mas os blocos principais em uma grande hierarquia de design normalmente possuem contagens de portas na casa dos milhares. SystemVerilog apresenta o conceito de interfaces para reduzir a redundância de declarações de nomes de portas entre os módulos conectados, bem como grupos e sinais abstratos relacionados em um pacote declarado pelo usuário. O conceito adicional é o modport, que mostra a direção das conexões lógicas.

Exemplo: 

interface intf;
  logic a;
  logic b;
  modport in (input a, output b);
  modport out (input b, output a); 
endinterface

module top;
  intf i ();
  u_a m1 (.i1(i.in));
  u_b m2 (.i2(i.out));
endmodule

module u_a (intf.in i1);
endmodule

module u_b (intf.out i2);
endmodule

Recursos de verificação

Os seguintes recursos de verificação normalmente não são sintetizáveis, o que significa que não podem ser implementados em hardware baseado em código HDL. Em vez disso, eles auxiliam na criação de bancos de teste extensíveis e flexíveis .

Novos tipos de dados

O stringtipo de dados representa uma string de texto de comprimento variável . Por exemplo: 

string s1 = "Hello";
string s2 = "world";
string p = ".?!";
string s3 = {s1, ", ", s2, p[2]}; // string concatenation
$display("[%d] %s", s3.len(), s3); // simulation will print: "[13] Hello, world!"

Além da matriz estática usada no design, SystemVerilog oferece matrizes dinâmicas , matrizes associativas e filas : 

int cmdline_elements; // # elements for dynamic array
int da[];             // dynamic array
int ai[int];          // associative array, indexed by int
int as[string];       // associative array, indexed by string
int qa[$];            // queue, indexed as an array, or by built-in methods

initial begin
    cmdline_elements = 16;
    da = new[ cmdline_elements ]; // Allocate array with 16 elements
end

Um array dinâmico funciona como um array desempacotado, mas oferece a vantagem de ser alocado dinamicamente em tempo de execução (como mostrado acima). Considerando que o tamanho de um array empacotado deve ser conhecido em tempo de compilação (a partir de uma constante ou expressão de constantes), o array dinâmico size pode ser inicializado a partir de outra variável de tempo de execução, permitindo que a matriz seja dimensionada e redimensionada arbitrariamente conforme necessário.

Uma matriz associativa pode ser considerada uma árvore de pesquisa binária com um tipo de chave e tipo de dados especificados pelo usuário . A chave implica um pedido ; os elementos de uma matriz associativa podem ser lidos em ordem lexicográfica. Finalmente, uma fila fornece muitas das funcionalidades do tipo deque C ++ STL : os elementos podem ser adicionados e removidos de qualquer uma das extremidades com eficiência. Essas primitivas permitem a criação de estruturas de dados complexas necessárias para o placar de um grande design.

Aulas

SystemVerilog fornece um modelo de programação orientado a objetos .

Em SystemVerilog, as classes suportam um modelo de herança única , mas podem implementar funcionalidade semelhante à herança múltipla por meio do uso das chamadas "classes de interface" (idênticas em conceito ao interfacerecurso de Java). As classes podem ser parametrizadas por tipo , fornecendo a função básica dos modelos C ++ . No entanto, a especialização de modelo e os modelos de função não são suportados.

Os recursos de polimorfismo do SystemVerilog são semelhantes aos do C ++: o programador pode escrever especificamente uma virtualfunção para que uma classe derivada ganhe o controle da função. Veja a função virtual para mais informações.

O encapsulamento e a ocultação de dados são realizados usando as palavras local- protectedchave e , que devem ser aplicadas a qualquer item a ser ocultado. Por padrão, todas as propriedades da classe são públicas .

As instâncias de classe são criadas dinamicamente com a newpalavra - chave. Um construtor denotado por function newpode ser definido. SystemVerilog tem coleta de lixo automática , portanto, não há nenhum recurso de linguagem para destruir explicitamente as instâncias criadas pelo novo operador .

Exemplo: 

virtual class Memory;
    virtual function bit [31:0] read(bit [31:0] addr); endfunction
    virtual function void write(bit [31:0] addr, bit [31:0] data); endfunction
endclass

class SRAM #(parameter AWIDTH=10) extends Memory;
    bit [31:0] mem [1<<AWIDTH];

    virtual function bit [31:0] read(bit [31:0] addr);
        return mem[addr];
    endfunction

    virtual function void write(bit [31:0] addr, bit [31:0] data);
        mem[addr] = data;
    endfunction
endclass

Geração aleatória restrita

Quantidades inteiras, definidas em uma definição de classe ou como variáveis ​​autônomas em algum escopo léxico, podem receber valores aleatórios com base em um conjunto de restrições. Este recurso é útil para criar cenários aleatórios para verificação .

Nas definições de classe, os modificadores rande randcsinalizam variáveis ​​que devem ser submetidas à randomização. randcespecifica a randomização baseada em permutação , onde uma variável assumirá todos os valores possíveis uma vez antes de qualquer valor ser repetido. Variáveis ​​sem modificadores não são randomizadas. 

class eth_frame;
    rand bit [47:0] dest;
    rand bit [47:0] src;
    rand bit [15:0] f_type;
    rand byte       payload[];
    bit [31:0]      fcs;
    rand bit [31:0] fcs_corrupt;

    constraint basic {
        payload.size inside {[46:1500]};
    }

    constraint good_fr {
        fcs_corrupt == 0;
    }
endclass

Neste exemplo, o fcscampo não é aleatório; na prática, ele será calculado com um gerador CRC e o fcs_corruptcampo usado para corrompê-lo para injetar erros de FCS. As duas restrições mostradas são aplicáveis ​​aos quadros Ethernet em conformidade . As restrições podem ser ativadas seletivamente; esse recurso seria necessário no exemplo acima para gerar quadros corrompidos. As restrições podem ser arbitrariamente complexas, envolvendo inter-relações entre variáveis, implicações e iterações. O solucionador de restrições SystemVerilog é necessário para encontrar uma solução, se houver, mas não oferece garantias quanto ao tempo que será necessário para fazê-lo, pois este é, em geral, um problema NP-difícil ( satisfatibilidade booleana ).

Métodos de randomização

Em cada classe SystemVerilog, existem 3 métodos predefinidos para randomização: pre_randomize, randomize e post_randomize. O método randomize é chamado pelo usuário para randomização das variáveis ​​da classe. O método pre_randomize é chamado pelo método randomize antes da randomização e o método post_randomize é chamado pelo método randomize após a randomização. 

class eth_frame;
    rand bit [47:0] dest;
    rand bit [47:0] src;
    rand bit [15:0] f_type;
    rand byte       payload[];
    bit [31:0]      fcs;
    rand bit        corrupted_frame;

    constraint basic {
        payload.size inside {[46:1500]};
    }
    
    function void post_randomize()
      this.calculate_fcs(); // update the fcs field according to the randomized frame
      if (corrupted_frame)  // if this frame should be corrupted 
        this.corrupt_fcs(); // corrupt the fcs
    endfunction
endclass

Controle de restrições

Os métodos constraint_mode () e random_mode () são usados ​​para controlar a randomização. constraint_mode () é usado para ligar e desligar uma restrição específica e o random_mode é usado para ligar ou desligar uma randomização de uma variável específica. O código a seguir descreve e testa processualmente um frame Ethernet : 

class eth_frame;
    rand bit [47:0] dest;
    rand bit [47:0] src;
    rand bit [15:0] f_type;
    rand byte       payload[];
    bit [31:0]      fcs;
    rand bit        corrupted_frame;

    constraint basic {
        payload.size inside {[46:1500]};
    }
   
    constraint one_src_cst {
        src == 48'h1f00
    }

    constraint dist_to_fcs {
        fcs dist {0:/30,[1:2500]:/50};  // 30, and 50 are the weights (30/80 or  50/80, in this example) 
    }

endclass
.
.
.
eth_frame my_frame;

my_frame.one_src_cst.constraint_mode(0); // the constraint one_src_cst will not be taken into account
my_frame.f_type.random_mode(0);        // the f_type variable will not be randomized for this frame instance.
my_frame.randomize();

Afirmações

As asserções são úteis para verificar as propriedades de um design que se manifestam depois que uma condição ou estado específico é atingido. SystemVerilog tem sua própria linguagem de especificação de asserção, semelhante à linguagem de especificação de propriedade . O subconjunto de construções de linguagem SystemVerilog que fornece asserção é comumente chamado de Asserção SystemVerilog ou SVA.

Asserções SystemVerilog são construídas a partir de sequências e propriedades . As propriedades são um superconjunto de sequências; qualquer sequência pode ser usada como se fosse uma propriedade, embora isso não seja normalmente útil.

As sequências consistem em expressões booleanas aumentadas com operadores temporais . O operador temporal mais simples é o ##operador que realiza uma concatenação: 

sequence S1;
    @(posedge clk) req ##1 gnt;
endsequence

Essa sequência corresponde se o gntsinal ficar alto um ciclo de clock após reqficar alto. Observe que todas as operações de sequência são síncronas a um relógio.

Outros operadores sequenciais incluem operadores de repetição, bem como várias conjunções. Esses operadores permitem que o designer expresse relacionamentos complexos entre os componentes do design.

Uma asserção funciona tentando continuamente avaliar uma sequência ou propriedade. Uma declaração falhará se a propriedade falhar. A sequência acima falhará sempre que reqestiver baixa. Para expressar com precisão o requisito que gntsegue requma propriedade é necessário: 

property req_gnt;
    @(posedge clk) req |=> gnt;
endproperty

assert_req_gnt: assert property (req_gnt) else $error("req not followed by gnt.");

Este exemplo mostra um operador de implicação|=> . A cláusula à esquerda da implicação é chamada de antecedente e a cláusula à direita é chamada de conseqüente . A avaliação de uma implicação começa por meio de tentativas repetidas de avaliar o antecedente. Quando o antecedente é bem-sucedido , o consequente é tentado e o sucesso da afirmação depende do sucesso do consequente. Neste exemplo, o consequente não será tentado até reqficar alto, após o que a propriedade falhará se gntnão estiver alto no relógio seguinte.

Além de afirmações, SystemVerilog oferece suporte a suposições e cobertura de propriedades. Uma suposição estabelece uma condição que uma ferramenta de prova de lógica formal deve assumir como verdadeira . Uma asserção especifica uma propriedade que deve ser comprovada como verdadeira. Na simulação , ambas as afirmações e suposições são verificadas em relação aos estímulos de teste. A cobertura da propriedade permite que o engenheiro de verificação verifique se as afirmações estão monitorando o projeto com precisão.

Cobertura

A cobertura aplicada a linguagens de verificação de hardware refere-se à coleta de estatísticas com base em eventos de amostragem dentro da simulação. A cobertura é usada para determinar quando o dispositivo em teste (DUT) foi exposto a uma variedade suficiente de estímulos para que haja uma alta confiança de que o DUT está funcionando corretamente. Observe que isso difere da cobertura de código, que instrumenta o código de design para garantir que todas as linhas de código no design foram executadas. A cobertura funcional garante que todos os cantos e casos extremos desejadosno espaço de design foram explorados .

Um grupo de cobertura SystemVerilog cria um banco de dados de "bins" que armazena um histograma de valores de uma variável associada. A cobertura cruzada também pode ser definida, o que cria um histograma que representa o produto cartesiano de várias variáveis.

Um evento de amostragem controla quando uma amostra é coletada. O evento de amostragem pode ser um evento Verilog, a entrada ou saída de um bloco de código ou uma chamada para o samplemétodo do grupo de cobertura. É necessário cuidado para garantir que os dados sejam amostrados apenas quando forem significativos.

Por exemplo: 

class eth_frame;
   // Definitions as above
   covergroup cov;
      coverpoint dest {
          bins bcast[1] = {48'hFFFFFFFFFFFF};
          bins ucast[1] = default;
      }
      coverpoint f_type {
          bins length[16] = { [0:1535] };
          bins typed[16] = { [1536:32767] };
          bins other[1] = default;
      }
      psize: coverpoint payload.size {
          bins size[] = { 46, [47:63], 64, [65:511], [512:1023], [1024:1499], 1500 };
      }

      sz_x_t: cross f_type, psize;
   endgroup
endclass

Neste exemplo, o engenheiro de verificação está interessado na distribuição de quadros de broadcast e unicast, o campo size / f_type e o tamanho da carga útil. Os intervalos no ponto de cobertura do tamanho da carga útil refletem os casos de canto interessantes, incluindo quadros de tamanho mínimo e máximo.

Sincronização

Um ambiente de teste complexo consiste em componentes de verificação reutilizáveis ​​que devem se comunicar uns com os outros. A primitiva de ' evento ' de Verilog permitia que diferentes blocos de instruções procedurais acionassem uns aos outros, mas impor a sincronização de thread dependia do uso (inteligente) do programador. SystemVerilog oferece duas primitivas especificamente para sincronização entre threads: caixa de correio e semáforo . A caixa de correio é modelada como uma fila de mensagens FIFO . Opcionalmente, o FIFO pode ser parametrizado por tipo, de forma que apenas objetos do tipo especificado podem ser passados ​​por ele. Normalmente, os objetos são instâncias de classe que representam transações : operações elementares (por exemplo, enviar um quadro) que são executadas pelos componentes de verificação. O semáforo é modelado como um semáforo de contagem .

Melhorias gerais no Verilog clássico

Além dos novos recursos acima, SystemVerilog aprimora a usabilidade dos recursos de linguagem existentes do Verilog. A seguir estão algumas dessas melhorias:

Além disso, SystemVerilog permite interface conveniente para idiomas estrangeiros (como C / C ++), por SystemVerilog DPI (Direct Programming Interface).

Software de verificação e síntese

Na função de verificação de projeto, SystemVerilog é amplamente utilizado na indústria de design de chips. Os três maiores fornecedores de EDA ( Cadence Design Systems , Mentor Graphics , Synopsys ) incorporaram o SystemVerilog em seus simuladores HDL de idioma misto . Embora nenhum simulador possa reivindicar suporte para todo o SystemVerilog LRM , tornando a interoperabilidade do testbench um desafio, esforços para promover a compatibilidade entre fornecedores estão em andamento. Em 2008, a Cadence e a Mentor lançaram a Metodologia de Verificação Aberta, uma biblioteca de classes e estrutura de uso de código aberto para facilitar o desenvolvimento de testbenches reutilizáveis ​​e verificação IP enlatada. A Synopsys, que foi a primeira a publicar uma biblioteca de classes SystemVerilog (VMM), posteriormente respondeu abrindo seu VMM proprietário ao público em geral. Muitos provedores de terceiros anunciaram ou já lançaram o IP de verificação SystemVerilog.

No projeto síntese papel (transformação de uma descrição de hardware-design em uma gateways netlist ), a adoção SystemVerilog tem sido lento. Muitas equipes de design usam fluxos de design que envolvem várias ferramentas de diferentes fornecedores. A maioria das equipes de projeto não pode migrar para o projeto SystemVerilog RTL até que todo o conjunto de ferramentas front-end ( linters , verificação formal e geradores de estrutura de teste automatizado ) ofereça suporte a um subconjunto de linguagem comum.

Veja também

Referências

  • 1800-2005 - Padrão IEEE para Sistema Verilog - Linguagem de design, especificação e verificação de hardware unificada . 2005. doi : 10.1109 / IEEESTD.2005.97972 . ISBN 978-0-7381-4810-6.
  • 1800-2009 - Padrão IEEE para SystemVerilog - Linguagem de design, especificação e verificação de hardware unificada . 2009. doi : 10.1109 / IEEESTD.2009.5354441 . ISBN 978-0-7381-6130-3.
  • 1800-2012 - Padrão IEEE para SystemVerilog - Linguagem de design, especificação e verificação de hardware unificada . 2013. doi : 10.1109 / IEEESTD.2013.6469140 . ISBN 978-0-7381-8110-3.
  • 1800-2017 - Padrão IEEE para SystemVerilog - Linguagem de design, especificação e verificação de hardware unificada . 2017. doi : 10.1109 / IEEESTD.2018.8299595 . ISBN 978-1-5044-4509-2.
  • McGrath, Dylan (2009-11-09). "IEEE aprova SystemVerilog, revisão de Verilog" . EE Times . Página visitada em 31/01/2007 .
  • Puneet Kumar (09/11/2005). "Tutorial do Sistema Verilog" .
  • Gopi Krishna (09/11/2005). "SystemVerilog, SVA, SV DPI Tutorials" .
  • HDVL. "Mais links da Web do SystemVerilog" .
  • Spear, Chris, "SystemVerilog for Verification" Springer, New York City, NY. ISBN  0-387-76529-8
  • Stuart Sutherland, Simon Davidmann, Peter Flake, "SystemVerilog for Design Second Edition: A Guide to Using SystemVerilog for Hardware Design and Modeling" Springer, New York City, NY. ISBN  0-387-33399-1
  • Ben Cohen, Srinivasan Venkataramanan, Ajeetha Kumari e Lisa Piper [1] SystemVerilog Assertions Handbook, 4ª edição, 2016- http://SystemVerilog.us
  • Ben Cohen Srinivasan Venkataramanan e Ajeetha Kumari [2] A Pragmatic Approach to VMM Adoption, - http://SystemVerilog.us
  • Erik Seligman e Tom Schubert [3] Verificação formal: Um kit de ferramentas essencial para o design VLSI moderno, 24 de julho de 2015,

links externos

Referência do padrão IEEE

Os documentos padrão SystemVerilog mais recentes estão disponíveis gratuitamente no IEEExplore .

Tutoriais
Desenvolvimento de Padrões
Extensões de linguagem
  • Verilog AUTOs - Um sistema de meta-comentários de código aberto para simplificar a manutenção do código Verilog
Ferramentas Online
  • EDA Playground - Execute SystemVerilog de um navegador da web (IDE online grátis)
  • SVeN - Um SystemVerilog BNF Navigator (atual para IEEE 1800-2012)
Outras Ferramentas
  • SVUnit - estrutura de teste de unidade para desenvolvedores que escrevem código em SystemVerilog. Verifique os módulos, classes e interfaces do SystemVerilog isoladamente.
  • sv2v - conversor de código aberto de SystemVerilog para Verilog