GERAÇÃO PROCEDURAL DE NETLIST E UTILIZAÇÃO DE FERRAMENTAS AUTOMÁTICAS DE LAYOUT

Prévia do material em texto

GERAÇÃO PROCEDURAL DE 
NETLIST E UTILIZAÇÃO DE 
FERRAMENTAS AUTOMÁTICAS DE 
LAYOUT 
 
 
 
 
 
 
 
Marcílio de Oliveira Silva Júnior 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CENTRO DE INFORMÁTICA 
UNIVERSIDADE FEDERAL DA PARAÍBA 
 
 
 
João Pessoa, 2020 
 
 2 
Marcílio de Oliveira Silva Júnior 
 
 
 
 
 
 
 
 
 
 
 
 
Relatório 11 
 
 
 
 
Relatório apresentado a disciplina Introdução à 
Microeletrônica do curso de Engenharia de 
Computação do Centro de Informática, da 
Universidade Federal da Paraíba. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Março de 2020 
 
 3 
RESUMO 
Este trabalho tem como objetivo, de forma resumida, recriar circuitos utilizando outras 
ferramentas. Inicialmente será relatado de forma introdutória o uso da biblioteca genlib.h, da 
Linguagem C para criação procedural de netlists como também layouts. 
Em seguida serão demonstrados a recriação de circuitos projetados em relatórios 
anteriores. 
Por fim, duas novas ferramentas serão apresentadas, também de forma introdutória. 
Primeiro será relatado o uso do OCP para organização das standards cells. Logo após, o uso do 
NeRo será visto para a interconexão das trilhas de alumínio entre as células. 
 
Palavras-chave: GENLIB; OCP; NERO; GERAÇÃO PROCEDURAL. 
 
 
 4 
Sumário 
1 GENLIB - PROCEDURAL GENERATION LANGUAGE ................................ 5 
1.1 GERAÇÃO PROCEDURAL ......................................................................... 5 
2 LATCH D ...................................................................................................... 6 
2.1 CRIANDO O LATCH D USANDO A BIBLIOTECA GENLIB ......................... 7 
3 FLIP-FLOP .................................................................................................. 9 
3.1 CRIANDO O FLIP-FLOP D USANDO A BIBLIOTECA GENLIB ................ 10 
4 NON-OVERLAPPING ................................................................................. 11 
4.1 FLIP-FLOP COM CLOCK DE DUAS FASES ............................................. 12 
5 OCP E NERO .............................................................................................. 14 
5.1 OCP - PLACER FOR STANDARDS CELLS .............................................. 14 
5.2 NERO - NEGOTIATING ROUTER ............................................................. 18 
 
 
 
 5 
1 GENLIB - PROCEDURAL GENERATION LANGUAGE 
O GENLIB é uma linguagem procedural que pode ser utilizada incluindo-se a 
biblioteca <genlib.h>. Consiste em um conjunto de funções que são voltadas para a 
criação de circuitos de grande porte de forma procedural, visando facilitar a vida 
daqueles que devem descrever circuitos complexos em linhas de código para que ocorra 
a criação da netlist ou das standard cells. 
Baseado sob a estrutura de dados MBK do Alliance, a linguagem do GENLIB 
disponibiliza ao usuário a capacidade de descrever tanto a netlist como os layouts de 
visualização, assim permitindo que tanto células padrão como a customização completa 
sejam abordadas. 
Essa ferramenta nos permite montar circuitos através de programação, 
utilizando a Linguagem C. Assim, podemos sequenciar instâncias da biblioteca para 
criar o circuito desejado. Desta maneira, algumas atividades podem ser realizadas de 
forma mais automatizada, tais como as ligações das células entre si, selecionar o tipo 
de alumínio para conexões sem causar curtos e mal posicionamento das células. 
1.1 Geração Procedural 
Para esta primeira parte, usaremos apenas um pequeno conjunto de instruções 
da biblioteca do GENLIB, que serão brevemente detalhadas abaixo. 
• GENLIB_DEF_LOFIG(): define o arquivo .vst a ser gerado na compilação. 
• GENLIB_LOCON(): declara os terminais de entrada e saída do circuito. 
• GENLIB_LOINS(): inclusão de instâncias e definição dos seus terminais 
internos. 
• GENLIB_SABE_LOFIG(): salva o arquivo .vst. 
 
 
 6 
2 LATCH D 
Como estudado anteriormente, o Latch D é um circuito que possui dois estados 
estáveis e que pode armazenar um bit. É utilizado para obter o nível lógico que está 
presente no circuito quando o clock está em nível alto. Quando o clock está em nível 
baixo, o Latch D mantém o nível lógico anterior que estava presente independente da 
entrada. As figuras abaixo exemplificam o funcionamento. 
 
 
Figura 1:Esquema de funcionamento do Latch D. 
 
 
Figura 2: Resposta (Q) do Latch D. 
 
 
 7 
2.1 Criando o Latch D usando a biblioteca GENLIB 
Para que possamos criar o código em Linguagem C utilizando a biblioteca 
genlib.h, gerar o arquivo .vst e posteriormente compilar usando o genlib, é sugerido 
seguir os passos indicados abaixo. É válido lembrar que estes procedimentos estão 
sendo realizados no Linux. 
Ao abrir uma nova janela do Terminal, digite: 
• export MBK_IN_LO=vst 
• gedit <nome_do_arquivo.c> 
Neste passo, na janela que abrir, escreva o código do circuito desejado, salve 
e feche a mesma. Lembre-se de que este documento deve estar com a 
extensão .c. Volte ao Terminal e digite: 
• export MBK_OUT_LO=vst 
• genlib <nome_do_arquivo> 
Neste passo, apenas o nome do arquivo deve ser digitado, sem extensão. 
É importante lembrar que o arquivo resultante deste passo terá o nome que 
foi definido na função GENLIB_DEF_LOFIG() e extensão .vst e não o 
nome que foi dado ao criar o arquivo contendo o código em .c. 
• xsch -l <nome_do_arquivo_gerado_acima.vst> 
Neste passo, será possível ver o circuito de forma esquemática após a 
compilação pelo genlib. 
Para a criação do Latch D, neste relatório, o seguinte código em C foi 
redigido. 
 
 
 8 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tabela 1: Código em Linguagem C para o Latch D utilizado neste relatório. 
 
Após realizados os procedimentos descritos anteriormente, obtemos o seguinte 
esquemático. 
 
 
Figura 3: Esquemático para o Latch D do código acima. 
#include <genlib.h> 
 
int main(void){ 
 
GENLIB_DEF_LOFIG("la_1_genlib"); 
 
//Pinos externos 
//Sintaxe: “nome”, IN para entrada e OUT para saída, “nome”. 
 
GENLIB_LOCON("a", IN, "a"); 
GENLIB_LOCON("ck", IN, "ck"); 
GENLIB_LOCON("q", OUT, "q"); 
GENLIB_LOCON("vdd", IN, "vdd"); 
GENLIB_LOCON("vss", IN, "vss"); 
 
//Instâncias 
//Sintaxe: (“arquivo da porta lógica”, “nome da instância”, “entrada”, “saída”, 
//“entrda da corrente”, “saída da corrente”, NULL (fim da instância)); 
 
GENLIB_LOINS("inv_x1", "inv_1", "b", "q", "vdd", "vss", NULL); 
GENLIB_LOINS("inv_x1", "inv_2", "q", "q_b", "vdd", "vss", NULL); 
GENLIB_LOINS("mx2_x2", "mux", "ck", "q_b", "a", "b", "vdd", "vss", NULL); 
 
GENLIB_SAVE_LOFIG(); 
 
return 0; 
 
} 
 
 9 
3 FLIP-FLOP 
Como já estudado anteriormente, os Flip-flops são derivados dos Latchs. A 
diferença aqui, é a forma da produção do resultado, uma vez que a saída só muda 
durante a borda de subida ou descida do clock, como mostram as figuras abaixo. 
 
 
Figura 4: Esquema de funcionamento do Flip-flop D. 
 
 
Figura 5: Resposta do Flip-flop D. 
 
 
 10 
3.1 Criando o Flip-flop D usando a biblioteca GENLIB 
Seguindo os passos descritos nas páginas anteriores, a partir de agora os detalhes 
para tais implementações serão suprimidos e apenas os códigos e seus esquemáticos 
referentes aos circuitos desejados serão demonstrados. As figuras abaixo demonstram 
a criação do Flip-flop D. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tabela 2: Código em Linguagem C para o Flip-flop D utilizado neste relatório. 
 
Figura 6: Esquemático para o Flip-flop D do código acima. 
#include <genlib.h> 
 
int main(void){ 
 
GENLIB_DEF_LOFIG("ff_1_m_e_genlib"); 
 
//Pinos externos 
//Sintaxe: “nome”, IN para entrada e OUT para saída, “nome”. 
 
GENLIB_LOCON("a", IN, "a"); 
GENLIB_LOCON("ck_m", IN, "ck_m"); 
GENLIB_LOCON("ck_e", IN, "ck_e"); 
GENLIB_LOCON("q", OUT, "q"); 
GENLIB_LOCON("vdd", IN, "vdd"); 
GENLIB_LOCON("vss", IN, "vss"); 
 
//Instâncias 
//Sintaxe:(“arquivo da porta lógica”, “nome da instância”, “entrada”, “saída”, 
//“entrda da corrente”, “saída da corrente”, NULL (fim da instância)); 
 
GENLIB_LOINSE("la_1_genlib", "la_m", "a =>a", "ck =>ck_m", "q =>q_m", "vdd =>vdd", 
"vss =>vss", NULL); 
GENLIB_LOINSE("la_1_genlib", "la_e", "a =>q_m", "ck =>ck_e", "q =>q", "vdd =>vdd", 
"vss =>vss", NULL); 
 
GENLIB_SAVE_LOFIG(); 
 
return 0; 
 
} 
 
 11 
4 NON-OVERLAPPING 
O circuito intitulado aqui como Non-Overlapping tem o intuito de gerar dois 
sinais sem que haja intereferências entre eles. Desta maneira, temos um gerador de 
sinais, phi_1 e phi_2, a fim de servirem como sinais de entrada no Flip-flop. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tabela 3: Código em Linguagem C para o Non-Overlapping utilizado neste relatório. 
 
#include <genlib.h> 
 
int main(void){ 
 
GENLIB_DEF_LOFIG("noc_genlib"); 
 
//Pinos externos 
//Sintaxe: “nome”, IN para entrada e OUT para saída, “nome”. 
 
GENLIB_LOCON("ck", IN, "ck"); 
GENLIB_LOCON("i5", OUT, "i5"); 
GENLIB_LOCON("i10", OUT, "i10"); 
GENLIB_LOCON("vdd", IN, "vdd"); 
GENLIB_LOCON("vss", IN, "vss"); 
 
GENLIB_LOINS("inv_x1", "inv0", "ck", "ck_b", "vdd", "vss", NULL); 
 
int i = 0; 
for(i = 1; i <5;i++){ 
GENLIB_LOINS("inv_x1", GENLIB_NAME("inv%d", i), GENLIB_NAME("i%d", i), 
GENLIB_NAME("i%d", i+1), "vdd", "vss", NULL); 
} 
 
for(i = 6; i<10;i++){ 
GENLIB_LOINS("inv_x1", GENLIB_NAME("inv%d", i), GENLIB_NAME("i%d", i), 
GENLIB_NAME("i%d", i+1), "vdd", "vss", NULL); 
} 
 
GENLIB_LOINS("no2_x1", "nor1", "ck", "i10", "i1", "vdd", "vss", NULL); 
GENLIB_LOINS("no2_x1", "nor2", "ck_b", "i5", "i6", "vdd", "vss", NULL); 
 
GENLIB_SAVE_LOFIG(); 
 
return 0; 
 
} 
 
 12 
 
Figura 7: Esquemático para o Non-Overlapping do código acima. 
 
4.1 Flip-flop com clock de duas fases 
Com a criação do Non-Overlapping, podemos criar um Flip-flop com um clock 
de duas fases. O código para criação deste circuito é mostrado abaixo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tabela 4: Código em Linguagem C para o Flip-flop com clock de duas fases utilizado 
neste relatório. 
#include <genlib.h> 
 
int main(void){ 
GENLIB_DEF_LOFIG("ff_1_noc_genlib"); 
 
//Pinos externos 
//Sintaxe: “nome”, IN para entrada e OUT para saída, “nome”. 
 
GENLIB_LOCON("a", IN, "a"); 
GENLIB_LOCON("ck", IN, "ck"); 
GENLIB_LOCON("q", OUT, "q"); 
GENLIB_LOCON("phi_1", OUT, "phi_1"); 
GENLIB_LOCON("phi_2", OUT, "phi_2"); 
GENLIB_LOCON("vdd", IN, "vdd"); 
GENLIB_LOCON("vss", IN, "vss"); 
 
//Instâncias 
//Sintaxe: (“arquivo da porta lógica”, “nome da instância”, “entrada”, “saída”, 
//“entrda da corrente”, “saída da corrente”, NULL (fim da instância)); 
 
GENLIB_LOINSE("noc_genlib", "noc", "ck =>ck", "i5 =>phi_1", "i10 =>phi_2", "vdd 
=>vdd", "vss =>vss", NULL); 
GENLIB_LOINSE("ff_1_m_e_genlib", "ff", "a =>a", "ck_m =>phi_1", "ck_e =>phi_2", "q 
=>q", "vdd =>vdd", "vss =>vss", NULL); 
 
GENLIB_SAVE_LOFIG(); 
return 0; 
} 
 
 13 
 
Este código resulta no seguinte circuito gerado atráves da geração procedural. 
 
 
Figura 8: Esquemático para o Flip-flop com clock de duas fases do código acima. 
 
 
 
 
 
 14 
5 OCP E NERO 
5.1 OCP - Placer for Standards Cells 
Apos a criação dos circuitos através dos passos apresentados anteriormente, 
precisamos, ainda, gerar as células e conexões. Para isso, continuaremos usando 
algumas ferramentas da biblioteca do Alliance. 
O OCP é o programa responsável por dispor de maneira correta as células do 
circuito que foram criadas anteriormente da forma mais organizada possível. 
O parâmetro de entrada para este programa é uma netlist com a extensão .vst e 
a saída será um arquivo com o layout (.ap) do circuito com a aplicação da metodologia 
Standard Cells. 
Em um Terminal aberto no diretório onde estejam os arquivos criados 
anteriormente, digite: 
• alliance-ocp -ring <arquivo_vst> <arquivo_saída> 
O parâmetro -ring cria conectores adequados para o posicionamento 
da ferramenta de gerado, a menos que um arquivo .ioc seja fornecido. 
Um arquivo .ioc é um tipo de arquivo que armazena os pinos de entrada 
e saída. 
Em <arquivo_vst> e <arquivo_saída> não é necessário explicitar 
as extensões dos arquivos de entrada e saída. 
Após a execução do comando citado acima, podemos usar o GRAAL para 
visualizar o resultado gerado. 
Os resultados do uso da ferramenta OCP nos circuitos criados anteriormente são 
demonstrados nas figuras a seguir. 
 
 
 15 
 
Figura 9: Layout do Latch, criado a partir do uso da ferramenta OCP. 
 
 
 16 
 
Figura 10: Layout do Flip-flop, criado a partir do uso da ferramenta OCP. 
 
 
 17 
 
Figura 11: Layout do Non-Overlapping, criado a partir do uso da ferramenta OCP. 
 
 
 18 
 
Figura 12: Layout do Flip-flop com clock de duas fases, criado a partir do uso da 
ferramenta OCP. 
 
5.2 NeRo - Negotiating Router 
O NeRo é uma ferramenta que realiza o posiconamento (ou roteamento) das vias 
de alumínio que são responsáveis pelas conexões entre as células. 
Novamente em um Terminal, onde estejam os arquivos criados até o momento, 
digite: 
• Nero -p <arquivo.ap> <arquivo.vst> <arquivo de saída> 
O parâmetro -p refere-se ao posicionamento (roteamento). 
 
 19 
Não é necessário incluir as extensões ao escrever os aquivos de entrada 
(.ap), (.vst) e arquivo de saída (.ap). 
 
Os resultados da aplicação da ferramenta NeRo nos arquivos criados nos passos 
anteriores são demonstrados nas figuras abaixo. 
 
 
Figura 13: Layout do Latch, criado a partir do uso da ferramenta NeRo. 
 
 
 20 
 
Figura 14: Layout do Flip-flop, criado a partir do uso da ferramenta NeRo. 
 
 
 21 
 
Figura 15: Layout do Non-Overlapping, criado a partir do uso da ferramenta NeRo. 
 
 
 22 
 
Figura 16: Layout do Flip-flop com clock de duas fases, criado a partir do uso da 
ferramenta NeRo.