Aplicação de Reescrita-Lógica na Especificação de Processadores

Aplicação de Reescrita-Lógica na Especificação de Processadores

Rinaldi Maya Neto

Prof. Orientador: Maurício Ayala – Rincón

Banca: Prof. Hermman Haeusler (PUC-RJ)

Prof.ª Alba Cristina Melo (UnB)

Prof. Ricardo Jacobi (UnB)

Universidade de BrasíliaDepartamento de Ciência da Computação

Aplicação de Reescrita-Lógica na Especificação de Processadores CIC/UnB – Nov/2002 2

Objetivos

• Descrever uma metodologia para simular a execução de programas assemblerassembler sobre processadores descritos através de sistemas de reescrita de termos

• Demonstrar as vantagens da utilização de um ambiente de reescrita-lógica

• Mostrar como avaliar diferentes implementações de arquiteturas simples


Roteiro

• Conceitos:– Teoria da Reescrita– Arquiteturas de Computadores

• Especificação de processadores simples usando Sistemas de Reescrita de Termos (Arvind et al)

• Demonstração da correção da especificação de processadores (Arvind et al)


Roteiro

• Utilização de Reescrita-Lógica para simulação de processadores.

• Avaliação do desempenho de diferentes especificações no ambiente de Reescrita-Lógica

• Ampliação do horizonte de utilização da Reescrita-Lógica na simulação de processadores


ConceitosTeoria da Reescrita

l

l => r se C

C r t[s ] t[ ] quando

• Regras dos SRTs Condicionais

• Forma Normal: Se u*v é irredutível, v é a forma normal


• Juntabilidade: u * w * v

• Terminação:– Não existem cadeias infinitas de redução

• Confluência

• Convergência:– Terminância e confluência

ConceitosTeoria da Reescrita

* *

* *


ConceitosArquiteturas de Computadores

• Processador– Caminho de Dados

• Memória de Instruções• Contador de Programa• Unidade Lógica e Aritmética• Banco de Registradores



• Processador– Unidade de Controle

• Busca• Decodificação• Execução



• Ganho de desempenho – Pipelining– Conceito: aproveitar os componentes ociosos

UAL

UAL

UAL

Te m po (e m c ic lo s d e c lo ck )

O rdem d e execu çãodo p ro g ram a(em instru çõ es )

1 2 3 4 5 6 7



• Resolvendo Conflitos– Reordenação/Execução Fora de Ordem

• Buffer de Reordenação (ITBs)

load reg1,reg4load reg2,reg5store reg2,reg4store reg0,reg5

load reg1,reg4load reg2,reg5store reg0,reg5store reg2,reg4

Escrito Executado



• Buffer de Alvo de Desvios (BTB)• Execução especulativa : 1- bit

Desvio Realizado

Previsão Correta

P revisão C orreta

P revisão Incorreta

P revisão Incorre ta



• Execução especulativa : 2- bit

Desvio FracamenteRea lizado

Previsão Correta

P revisão Incorreta

P revisão Incorre ta

Desvio Fortem enteRea lizado

Previsão Corre ta P revisão Incorreta

P revisão Corre ta

Desvio Fortem enteNão Realizado

Previsão C orre ta P revisão Incorre ta


Especificação de Processadores usando SRT

• Aplicando técnicas de reescrita no projeto de hardware [Arvind et al]– Especificação de processadores corretos; – Especificação correta de novas características de

processadores • Buffers de reordenação• Execução especulativa

– Outras contribuições : formulação de circuitos digitais lógicos simples; protocolos de cache em sistemas de memórias



Reescrita

VHDL/Verilog

Especificação

Provar Correção

Simulação + Verificação

Análise

Translação

Especificação



• Arquitetura AX – Conjunto de Instruções:

r:=Loadc(v) r:=Loadpc r:=Op(r1,r2) Jz(r1,r2)

r:=Load(r1) Store(r1,r2)

• Processador Pb– Ciclo único, execução em ordem, sem pipeline



+1

RegisterFile

Int MemPC ALU

Data Mem

PROC(ia,rf,prog)

SYS(mem,Proc)



No contexto da especificação de processadores:• Termos representam estados e• regras de reescrita as transformações entre

estados, de acordo com o conjunto de instruções dos processadores.

• Começando de um estado inicial através da aplicação de regras simula-se o comportamento dos processadores.



Regra para LoadcProc(ia,rf,prog) Proc(ia+1, rf[r:=v],prog)se prog[ia] = r:=Loadc(v)Regra para LoadpcProc(ia,rf,prog) Proc(ia+1, rf[r:=ia], prog)se prog[ia] = r:=LoadpcRegra para OpProc(ia,rf,prog) Proc(ia+1, rf[r:=v], prog)onde v =Op(rf[r1],rf[r2]se prog[ia] = r:=Op(r1,r2)Regra para Jz-JumpProc(ia,rf,prog) Proc(rf[r2], rf, prog)se prog[ia] = Jz(r1,r2) e rf[r1]=0

Regra para Jz-NoJumpProc(ia,rf,prog) Proc(ia+1, rf, prog)se prog[ia] = Jz(r1,r2) e rf[r1]!=0Regra para LoadSys(m, Proc(ia,rf,prog)) Sys(m,Proc(ia+1,

rf[r:=m[a]], prog))onde a=rf[r1]se prog[ia] = r:=Load(r1)Regra para StoreSys(m,Proc(ia,rf,prog)) Sys(m',Proc(ia+1,

rf, prog))onde a = rf[r1]se prog[ia] = r:=Store(r1,r2)

Regras para o processador Pb : Rb



• Termo inicial:

Sys(Cell(1,232).Cell(2,4).nil,Proc(1,Reg(1,0).Reg(2,0).Reg(3,0).Reg(4,0).nil,Inst(1,1:=Loadc(1)).nil))

• Termo após aplicar Regra para Loadc:

Sys(Cell(1,232).Cell(2,4).nil,Proc(2,Reg(1,1).Reg(2,0).Reg(3,0).Reg(4,0).nil,Inst(1,1:=Loadc(1)).nil))



• Processador Ps: – Pipelined, execução especulativa e fora de ordem

• Novos elementos– Buffer de reordenação : ITBs– Buffer para alvo de desvios: BTB



RegisterFile

Int Mem

PC

Data Mem

Reorder BufferROB

ALUs

BTBbranch

pmb

mpb

Commit

Fetch/Decode/Rename

Kill

Execute

Kill/Update BTB

PROC(ia,rf,itb,btb,prog)

SYS(mem,Proc)



Regras para Operações Aritméticas e Propagação de Valores

Ps-Op Ps- PropagaValor

Ps-PropagaValorRegistradores

Regras para Tratamento de Desvios Ps-Jz-DesvioEspeculacaoCorreta

Ps-Jz-DesvioEspeculacaoIncorretaPs-Jz-SemDesvioEspeculacaoCorretaPs-Jz-PsSemDesvioEspeculacaoIncorreta

Regras de Emissão de InstruçõesPs-Loadc-Emite Ps-Loadpc-Emite Ps-Op-Emite Ps-Jz-Emite Ps-Load-Emit

Ps-Store-Emite

Regras de Acesso à Memória Ps-LoadPs-Store

RITBF

Conjunto de Regras - Rs



Ps-Op Proc(ia,rf, itbs1+ ITB(ia1,k,t:=Op(vt:=Op(v11,v,v22),), wf,sf) + itbs2, btb,prog)) =>

Sys(m,Proc(ia,rf, itbs1 + ITB(ia1,k,t:=vt:=v)),wf,sf).+ itbs2, btb, prog)

Onde v = Op(vv1,1, v v22))

Ps-Jz-EmiteProc(iaia,rf,itbsitbs,btb,prog)) =>

Sys(m, Proc(piapia,rf, itbs + ITBITB(ia,k,Jz(tv(ia,k,Jz(tv11,tv,tv22)), NoWreg,Spec(pia)),itbs), btb,prog) Se prog[ia] = Jz(r1,r2) Onde pia=btb[ia]



Ps-Jz-DesvioEspeculacaoCorreta Proc(ia,rf,itbs1 + ITB(ia1,k, Jz(0,nia), Jz(0,nia), wf,Spec(pia)) + itbs2,

btb,prog)) => Proc(ia,rf,itbsitbs11 + itbs + itbs22, btb’, prog)

Se pia = niaSe pia = nia



t1:=Op(v’,v’’) t2:=Load(t’) t3:=Op(t2,t1)

Programa:...ro:=Op(r1,r2)r3:=Load(r4)r5:=Op(r3,r1)...

Regras de Emissão

Execução no interior do Buffer

Memory Register FileValores Propagados

t0:= v ...

Ps-Op-Emite: Proc(ia,rf,itbs,btb,[...(ia,r5:=Op(r3,r1)...])

Proc(ia+1,rf,itbs+ITB(ia,t3:=Op(t2,t1)),btb,prog)

Ps-PropagaValorRegistrador:Proc(ia,rf,ITB(t:=v)+itbs,...)

Proc(ia,rf[r:=v],itbs,...)



Jz(0,nia),Spec(pia) t2:=Load(t’) t3:=Op(t2,t1)

Programa:...r3:=Load(r4)r5:=Op(r3,r1)...

Regras de Emissão

Execução no buffer

Memory Register FileValores Propagados

t0:= v ...

Ps-Jz-DesvioEspeculacaoIncorreta:Proc(ia,rf,itbs1 + ITB(ia,Jz(0,nia),Wreg, Spec(pia))+itbs2, btb, prog)

Proc(nia,rf,itbs1, btb’, prog)


Correção das Especificações

Especificação

Provar Correção


Análise



• RS simula RB

• RB simula RS:

Em algum momento durante a execução do processador especulativo, se nenhuma instrução estiver sendo emitida o ITBs logo será esvaziado, já que apenas regras de emissão de instruções podem acrescentar elementos ao ITBs. Assim, podemos definir um outro sistema de reescrita, RITBF, que é composto por todas as regras de RS com exceção das regras de emissão de instruções.



RB simula RS: RS

Termos do processador especulativo s t

RITBF ! !

Termos do processador básico ITBF( s ) * ITBF( t ) RB

Notação ITBF(s) resultado da eliminação do ITBs vazio e do BTB


Simulação Usando Reescrita-Lógica

Filosofia de “Reescrita-Lógica”: combinação das possibilidades da reescrita e de estratégias lógicas para controlar a aplicação de regras de reescrita.

Ambientes de programação bem conhecidos como: – Maude [J. Meseguer, SRI Int. CSL, Menlo Park CA] – ELAN [C. kirchner, LORIA/INRIA, Nancy France] and– Cafe-OBJ [JAIST, Japan] are available.



AnáliseAnálise

Simulação + VerificaçãoSimulação + Verificação


Reescrita

VHDL/Verilog

-Lógica

VHDL/Verilog

Especificação

Provar Correção



• Simulação e avaliação de desempenho usando um ambiente de reescrita-lógica

• Lógica + reescrita nos permite:• Discriminar componentes arquiteturais• Execução de descrições de programas assembly• Controlar o comportamento de componentes do

processador



Lógica eestratégias

EspecificaçãoBaseada em Reescrita

Super usuário

Programador

SistemaComputacional

Motor deReescrita

Estado Inicial:Código Assembly e Estado corrente da

memória

Consulta

ResultadoEstado Final:

Estado do Processador após execução

Instruções, predições

Controle dos BUFFERS

TranformaçõesTranformações



Regras de Reescrita

• Usadas para especificar o conjunto de instruções

• Usadas para especificar o método de predição de desvio



Reescrita-lógica/estratégias Controle Como aplicar regras.

Características como tamanho e forma de trabalhar com o ITBs podem ser determinados através de estratégias.



select one( {issue rules} ); select one( {issue rules}{id} ); repeat * n-1 select one( {issue rules}{id} ); normalize( select one( {non issue rules} )

Controle do tamanho do ITBs usando estratégias.

RITBF


Simulação Usando Reescrita-LógicaRegras de Emissão

ITB ITB ITB ITB

1234

Normalizar Op AritméticaAcesso a MemóriaPropaga ValoresPropaga Valores p/ Reg


Simulação Não Determinística

• Uso do construtor dc (don’t know choose)– retorna todas as reduções possíveis

• Desempenho da simulação é inferior porém os resultados são mais próximos da situação real.


AnáliseAnálise


Avaliando Desempenho de Processadores

Especificação

Provar Correção



Estatísticas do ELAN número de regras aplicadas

Analizando o desempenho de implementações de processadores.

Exemplo: Número de predições corretas e incorretas quanto executando sobre mesmo processador com diferentes mecanismos de especulação

Contando o número de aplicações das regras:PsJumpCorrectSpecPsNoJumpWrongSpecPsJumpWrongSpecPsNoJumpWrongSpec



• Predição Especulativa de Um Bit Vs Dois Bits Tamanho 10 10 20 20 30 30 40 40 50 50

1-bit Predição ale ord ale ord ale ord ale ord ale ord

Correto 51 60 128 225 218 490 324 855 398 1320

Errado 29 34 66 74 106 114 148 154 194 184

2-bit Correto 50 73 134 258 216 543 323 928 404 1413

Errado 30 21 60 41 108 61 149 81 188 101


Detalhamento da Especificação de Processadores

• Alcançar outros níveis de detalhe• Simulação das fases de execução de uma

instrução:

busca-decodificação-execução



nilr : REG;Reg(@,@) : ( int int ) register;@.@ : ( register REG ) REG;Rf(@,@,@,@,@,@,@) : (int int int int int int REG ) RF;

• Representando o banco de registradores em detalhe



[Fetch]Proc(ia,Im(a,inst,cm),rf,alu,dm) =>

Proc(ia+1,Im(ia,FetchInst(ia,cm),cm),rf,alu,dm) end

• Uma única regra realiza a busca das instruções



[Decode]Proc(ia,Im(a,inst,cm),Rf(oldvalue1,oldvalue2,oldvalue3,oldvalue4,oldvalue5,oldvalue6,reg),alu,dm) =>

Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue,secondvalue,data,reg),alu,dm)

where firstop:=()DecodeOp(1,inst,a)where secondop:=()DecodeOp(2,inst,a)where regdest:=()DecodeOp(3,inst,a)where firstvalue:=()ValueOfReg(firstop,reg)where secondvalue:=()ValueOfReg(secondop,reg)where data:=()DecodeOp(4,inst,a) end

• Uma única regra realiza a decodificação das instruções



[Execute]Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue,secondvalue,data,reg),alu,dm) =>

Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue, secondvalue, data,Ins(reg,regdest,data)),alu,dm)if isinstLoadc(inst) end

• Existe ao menos uma regra por instrução para realizar a execução das instruções



[Execute]Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue,secondvalue,data,reg),Alu(oper,op1,op2,opout),dm) =>

Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue, secondvalue,data,Ins(reg,regdest,opresult)),Alu(1,firstvalue,secondvalue,opresult),dm)

where opresult:=()op(1,firstvalue,secondvalue)if isinstAdd(inst) end

[Execute]Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue,secondvalue,data,reg),alu,dm) =>

Proc(ia,Im(a,inst,cm),Rf(firstop,secondop,regdest,firstvalue,secondvalue,data,Ins(reg,regdest,data)),alu,dm)

if isinstLoadpc(inst) end



first one(fetch); first one(decode);

first one(execute);

•O Controle da aplicação das regras é efetuado através de uma estratégia


Análise


Conclusões

Especificação

Provar Correção


Análise

Reescrita

VHDL/Verilog

Reescrita-Lógica

Arvind et alArvind et al Este TrabalhoEste Trabalho


Conclusões

• Apontamos como simular um comportamento não determinístico na simulação

• Mostramos como descrever arquiteturas com um maior grau de precisão usando reescrita-lógica


Divulgação• M. Ayala-Rincón, R. Maya Neto, R. P. Jacobi, C. Llanos, and R.

Hartenstein. Applying ELAN Strategies in Simulating Processors over Simple Architectures. In 2nd Int. Workshop on Reduction Strategies in Rewriting 1and Programming - WRS'02, pages 127-141, Jul 2002.

• M. Ayala-Rincón, R. Hartenstein, R. P. Jacobi and C. Llanos, Designing Arithmetic Digital Circuits via Rewriting-Logic, http://www.mat.unb.br/~ayala/publications.html

• M. Ayala-Rincón, R. Maya Neto, R. P. Jacobi, C. Llanos and R. Hartenstein, Architectural Specification and Simulation Through Rewriting-Logic, http://www.mat.unb.br/~ayala/publications.html

• Protótipos: http://www.mat.unb.br/~ayala/Tcgroup

Aplicação de Reescrita-Lógica na Especificação de Processadores

Documents

Transcript of Aplicação de Reescrita-Lógica na Especificação de Processadores