µinstruções µoperações representadas em binário podem ser compactadas numa só µinstrução exemplo (as 3 últimas µinstruções anteriores):

Transcrição

1 µinstruções µoperações representadas em binário cada µoperação é realizada por um ou mais 1s cada bit é um sinal de controlo (excepto rrr_oe) podem ser compactadas numa só µinstrução exemplo (as 3 últimas µinstruções anteriores): _000_00_011100_ _000_0011 // (011h) ACC <- ACC or MBR_u _000_10_011000_ _000_0000 // (012h) ACC <- ACC << _000_00_000000_ _001_0000 // (013h) fetch _000_00_110101_ _000_0001 // (014h) PC <- PC _000_00_011100_ _000_0011 // (015h) ACC <- ACC or MBR_u _000_00_000000_ _000_0000 // (016h) goto 0 91

2 Representação simbólica Escrita directa em é confusa! Representação simbólica das µoperações loads de registos, activação de sinais, saltos... reg <- reg1 [opr reg2] rd; wr; fetch goto nnn; goto(mbr); if (Z) goto xxx else goto yyy restrições impostas pela µarquitectura tradução posterior para binário (à mão...) Cada µinstrução é executada num ciclo as suas µoperações são realizadas em paralelo minimizar o número de µinstruções (desempenho) 92

3 Escrita do µprograma ficheiro microcode.bin contém o µcódigo contém as 512 linhas com 38 bits cada cada linha tem o seu endereço como comentário cada µinstrução tem o endereço da seguinte o endereço actual+1 pode-se escrever xxxxxxxxx ver em controlpath.v como é efectuada e processada a leitura cada µinstrução deve conter as operações simbólicas ver os exemplos já apresentados das instruções implementadas 93

4 Projecto da µarquitectura Compromisso custo <-> desempenho custo = área ou complexidade do circuito (# gates!) desempenho = rapidez na execução de programas máquinas simples não são rápidas e vice-versa... Aumentar o desempenho reduzir o número de ciclos de relógio por instrução boa programação da unidade de controlo re-organização do datapath sobrepor a execução das instruções (pipelining) reduzir o ciclo de relógio (aumentar a frequência) 94

5 Reorganização do controlo fetch e decode na mesma µinstrução na implementação apresentada 2 ciclos de relógio para a fase de fetch e decode se MBR for sempre carregado com o próximo byte decode e fetch numa só µinstrução (MBR já tem instr.) cada instrução tem de deixar em MBR o próximo byte _100_00_110101_ _001_0001 // fetch;pc<-pc+1;goto(mbr) memória de programa: op1op2 op3 MBR já tem op1 (salta para op1); lê op2; PC aponta op3 E no início, quando MBR não tem ainda opcode?» Qual é o ganho de desempenho se consegue? 95

6 Reorganização do controlo (2) Sobrepor fetch e decode com a última µinstrução o ciclo principal pode ser eliminado (parcialmente) no final de cada instrução salta logo para a próxima exemplo (instrução LOAD ACC): MBR tem x _000_10_010100_ _000_0011 // (015h) ACC<-(MBR_u << 8); _000_00_110101_ _001_0001 // (016h) PC<-PC+1;fetch lê x _000_10_011100_ _000_0011 // (017h) ACC<-(ACC or MBR_u) << _000_00_110101_ _001_0001 // (018h) PC<-PC+1;fetch lê x _000_10_011100_ _000_0011 // (019h) ACC<-(ACC or MBR_u) << _000_00_110101_ _001_0001 // (01Ah) PC<-PC+1;fetch lê x _000_00_011100_ _000_0011 // (01Bh) MAR<-(ACC or MBR_u) lê op _000_00_ _011_0001 // (01Ch) rd;fetch;pc<-pc _000_00_010100_ _000_0000 // (01Dh) ACC<-MDR;fetch;PC<-PC+1;goto(MBR) memória de programa: op1 x3 x2 x1 x0 op2 y3 y2 lê y3; PC aponta y2; MBR já tem op2, salta para op2 96

7 Reorganização do datapath Estender o barramento A A e B podem ser alimentados de qualquer registo operando esquerdo da ALU pode ser qualquer reg ACC deixa de ser registo especial quanto custa? 4 bits na µinstrução (codificando como para B) espaço ocupado (buffers e barramentos) quais as instruções que beneficiam desta alteração? para a nossa ISA apenas as instruções de salto (porquê?) 97

8 Reorganização do datapath (2) Incluir um incrementador no PC PC pode ser incrementado sem usar a ALU (PC++) um somador com 1 apenas usa half-adders requer um bit mais na µinstrução (verdade?) exemplo (com a instrução LOAD ACC): _000_10_ _ _001_0011 // (015h) ACC<-(MBR_u << 8);PC++;fetch _000_10_ _ _001_0011 // (017h) ACC<-(ACC or MBR_u)<<8;PC++;fetch _000_10_ _ _001_0011 // (019h) ACC<-(ACC or MBR_u)<<8;PC++;fetch _000_00_ _ _000_0011 // (01Bh) MAR<-(ACC or MBR_u) _000_00_ _ _011_0000 // (01Ch) rd;fetch;pc _100_00_ _ _001_0000 // (01Dh) ACC<-MDR;fetch;PC++;goto(MBR) memória de programa: op1 x3 x2 x1 x0 op2 y3 y2 6 ciclos em vez dos 12 ciclos iniciais! 98

9 Reorganização do datapath (3) unidade dedicada para fetch liberta a unidade de controlo e o datapath carrega automaticamente bytes da memória agrupa 4 bytes para formar operandos de 32 bits dois portos de acesso à memória de programa: MBR8 tem sempre o próximo byte MBR32 tem sempre a próxima palavra de 32 bits leituras sucessivas de palavras de 32 bits desempenho condicionado pelo acesso de 8 bits à mem. 99

10 Unidade de prefetch shift register program RAM data 8 addr P0 P1 P2 P3 shift load fetch prefetch control read32=mbr_oe32 read8= MBR_oe8_s OR MBR_oe8_u 0 1 inc ldpc PC C bus 32 8 ready read8 read32 B bus MBR_oe32 MBR_oe8_s MBR_oe8_u PC_en PC_oe controlpath 100

11 Unidade de prefetch - controlo PC tem sempre o endereço do próximo byte+1 P3 tem sempre o próximo byte o shift register tem sempre os próximos 4 bytes quando é lido um byte (read8=1) fica disponível no bus B (com ou sem sinal) é lido um novo byte e deslocado no shift register quando é lida uma word (read32=1) está imediatamente disponível no bus B carregar o shift register requer 4 ciclos de relógio só pode ser feita nova leitura de 32 bits quando ready==1 101