Organización del Computador I Verano Procesador Multiciclo Basado en el capítulo 5 del libro de Patterson y Hennessy Verano 2004 Profesora Borensztejn

Diseño monociclo Diseño multiciclo Todas las instrucciones tardan tanto como la más lenta Ciclo de reloj es largo, pero CPI=1 No hay reuso de unidades funcionales Diseño multiciclo Reduce el tiempo de ciclo Un ciclo de reloj=una etapa de ejecución Reuso de Unidades Funcionales Cada instrucción puede utilizar o no todas las etapas, el CPI > 1.

Único ciclo Multiciclo Sistema Combinacional Registro/memoria Sistema Combinacional A Sistema Combinacional B Fetch Lectura Op. Ejecución Memoria Op. Escritura Op. En un ciclo: Como máximo una operación de la ALU, un acceso a memoria, un acceso a Registros===> la duración del ciclo puede ser tan corta como la más larga de estas operaciones.

Cinco Etapas de Ejecución Fetch de Instrucción (Fetch) Decodificación y Lectura (Decode) Ejecución, Cálculo de Dirección de memoria (X: execution) Acceso a datos en memoria (Memory) Escritura en registros (Write Back) Las instrucciones tardan de 3 a 5 ciclos

Diseño del Procesador 1er Paso: ISA + RTL 2o Paso: Componentes del Camino de Datos 3er Paso: RTL + Componentes===>> Camino de Datos 4o Paso: Camino de Datos + RTL==> Transferencias Físicas de Registros 5o Paso: RTs físicas ===>> Control

2o Paso: Componentes Una única ALU, una única Memoria, un único Banco de Registros Problemas con el uso de los recursos?? Dos tipos de problemas: Una instrucción utiliza un mismo recurso varias veces y se pierden los valores anteriores Una instrucción utiliza un mismo recurso en la misma etapa para dos o mas cosas distintas.

Uso de U.F Paso Registros ALU Memoria Fetch Todas PC<--PC+4 Todas Inst<--M[PC] Lectura Todas Eje Tipo R: operación Lw y Sw: dirección Beq: operación y dirección !! Mem Lw y Sw PostW Lw Tipo R

Uso de U.F Instrucción Registros ALU Memoria Tipo R Lectura/WB Fetch/Eje Fetch Lw Lectura/WB Fetch/Eje Fetch/Memoria Sw Lectura Fetch/Eje Fetch/Memoria Beq Lectura Fetch/Decod/Eje. Fetch

Mas componentes Para solucionar el problema de usar la ALU para dos etapas distintas: fetch y ejecución, necesitamos.......... Para solucionar el problema de usar la Memoria para las etapas de fetch y acceso a memoria necesitamos......... Para solucionar el problema de usar la ALU para las etapas de fetch, ejecución y cálculo de dirección destino de salto necesitamos........

3er Paso: Reuso de Unidades Funcionales: Memoria Única Una sola memoria para instrucciones y datos IoD IRW WE Del PC dirección MUX 32 Dato Out De la ALU 32 IR Memoria Dato In 32 CLK

3er Paso: Reuso de Unidades Funcionales: ALU única ALU debe realizar operaciones sobre registros base + desplazamiento para loads y stores dirección destino de salto: registro + signo_ext(inmm16) * 4 PC=PC+4 ALUctr PC 32 MUX BusA 32 32 BusB 32 MUX 4 32 Inm16 SignExt 32 >>2

3er Paso: Registro Destino (Beq) DstW ALUctr Destino PC 32 MUX BusA 32 32 BusB 32 MUX 4 32 Inm16 SignExt 32 >>2

3er Paso:Juntando Todo Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

4o Paso:Tipo R (add, sub..) Transferencias Lógicas (RTL) ADDU R[rd]<-- R[rs]+R[rt]; PC<--PC+ 4 Transferencias Físicas IR<---MEM[PC]; PC<--PC+ 4; BusA<---R[rs]; BusB<---R[rt] BusS<---BusA+BusB R[rd]<--BusS

Add: Lectura Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Add: Ejecución Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Add: Write Back Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

4o Paso:Tipo I (lógicas con inmediato) Transferencias Lógicas (RTL) ORI R[rt]<-- R[rs] OR zx(Inm16); PC<--PC+ 4 Transferencias Físicas IR<---MEM[PC] ; PC<--PC+ 4; BusA<---R[rs]; BusS<---A OR Zeroext(inm16) R[rt]<--BusS

4o Paso:Load Transferencias Lógicas (RTL) Transferencias Físicas Lw R[rt]<-- MEM(R[rs] + sx(Inm16)); PC<--PC+ 4 Transferencias Físicas IR<---MEM[PC]; PC<--PC+ 4; BusA<---R[rs]; BusS<---BusA+ Signext(inm16); dato<---MEM[S]; R[rt]<--dato

Instrucción load: Fetch Pcsrc DstW MUX Dst RegDst RegW ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Load : Lectura Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Load : Ejecución Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Load : Memoria Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

Load : Write Back Pcsrc DstW MUX RegW >>2 Dst RegDst ZERO AluselA 32 ALUctr rs LRA PCW 5 IRW rt LRB MUX WE 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 CLK Inm16 >>2 EXtension Ex/Op

4o Paso:STORE Transferencias Lógicas (RTL) Transferencias Físicas SW MEM(R[rs] + sx(Inm16))<-- R[rt]; PC<--PC+ 4 Transferencias Físicas IR<---MEM[PC]; PC<--PC+ 4; BusA<---R[rs]; BusB<---R[rt]; BusS<---BusA+ Signext(inm16); MEM[S]<--BusB;

4o Paso:BEQ Transferencias Lógicas (RTL) Transferencias Físicas BEQ if (R[rs]==R[rt]) then PC<--PC+4+(signext(Inm16)*4) else PC<--PC+ 4 Transferencias Físicas IR<---MEM[PC]; PC<--PC+ 4; BusA<--R[rs]; BusB<--R[rt]; DST<-PC+Signext(inm16)*4; Z<-- (BusA==BusB) ; si (Z) entonces PC<---DST;

Etapas de cada instrucción Paso Tipo R Load Store Lógicas Beq Fetch IR<----MEM[PC]; PC<--PC+4 Lectura A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Eje S<---AopB; S<---A+ signext(inm16); S<---A op Z<---AopB Zext(inm16) si (Z) PC<--DST Mem R[rd]<---S; dato<---MEM[S]; MEM[S]<--B; R[rt]<---S; PostW R[rt]<---dato;

4o Paso:Juntando Todo Pcsrc DstW MUX RegW >>2 PCW Salto Dst RegDst RegW ZERO AluselA 32 ALUctr rs LRA IRW 5 rt MUX WE LRB 5 32 BusA IoD 32 WR MUX 5 32 Registros de 32 bits 32 BusB Memoria rd MUX PC instrucción W_src 4 @ 32 BusW MUX 32 AluselB CLK CLK 32 Inm16 >>2 EXtension Ex/Op

Grafo de Estados IR<--MEM[PC]; PC<-PC+4 A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Z<---AopB si (Z) PC<--DST S<---AopB S<---A+ signext(inm16) MEM[S]<--B dato<---MEM[S] R[rt]<---dato R[rd]<---S

Grafo de Estados S0 S1 S6 S8 S2 S5 S3 S4 S7

Control S0 S1 S2 S3 S4 S5 S6 S7 S8 DstW RegW IRW WE PCW Salto PCsrc ALUselA ALUselB W_src RegDst IoD ALUop Ex/Op

Control S0 S1 S2 S3 S4 S5 S6 S7 S8 DstW 0 1 0 0 0 0 0 0 0 RegW 0 0 0 0 1 0 0 1 0 IRW 1 0 0 0 0 0 0 0 0 WE 0 0 0 0 0 1 0 0 0 PCW 1 0 0 0 0 0 0 0 0 Salto 0 0 0 0 0 0 0 0 1 PCsrc 0 0 x x x x x x 1 ALUselA 0 0 1 1 1 1 1 1 1 ALUselB 01 11 10 10 10 10 00 00 00 W_src x x x x 1 x x 0 x RegDst x x x x 0 x x 1 x IoD 0 x x 1 1 1 x x x ALUop 00 00 00 xx xx xx 10 xx 01 Ex/Op x 1 1 1 1 1 x x x

Control: Especificación e Implementación Representación Inicial Diagrama de Estados Finitos Microprograma Control del Secuenciamiento Función explícita del estado futuro Contador de microprograma + ROM Representación Lógica Ecuaciones Lógicas Tabla de Verdad Técnica de Implementación Array Lógico Programable ROM Control microprogranado Control cableado

Máquina de Estados Finitos Implementación: PCW Branch IoD WE PCsrc IRW C o n t r o l l o g i c W_src ALUop O u t p u t s ALUselB ALUselA RegW RegDst N S 3 N S 2 N S 1 I n p u t s N S 5 4 3 2 1 p p p p p p O O O O O O 3 2 1 S S S S I n s t r u c t i o n r e g i s t e r S t a t e r e g i s t e r o p c o d e f i e l d

Rendimiento El diagrama de estados nos da el CPI por instrucción (y el camino crítico) Tipo CPI Frecuencia CPIxFrecuencia ALU 4 40% 1.6 Load 5 30% 1.5 Store 4 10% 0.4 Branch 3 20% 0.6 CPI Medio= 4.1

Problema 1 Comparar el rendimiento de una máquina de 500Mhz, con el rendimiento de otra máquina de 750 Mhz pero en la cual el acceso a memoria de datos tarda dos ciclos. Tipo CPI1 CPI2 %inst CPI1x %inst CPI1x %inst ALU 4 4 40% 1.6 1.6 Load 5 6 30% 1.5 1.8 Store 4 5 10% 0.4 0.5 Branch 3 3 20% 0.6 0.6 CPI 1Medio= 4.1 CPI2 Medio= 4.5

Problema 2.a Diseñar el control de la máquina multiciclo suponiendo que las escrituras del Banco de Registros se realizan en el mismo ciclo que la operación de la ALU o que la lectura a memoria. Calcular el camino crítico de esta máquina. Paso Tipo R Load Store Lógicas Beq Fetch IR<----MEM[PC]; PC<--PC+4 Decod A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Eje S<---AopB; S<---A+ signext(inm16); S<---A op Z<---AopB R[rd]<---S; Zext(inm16) si (Z) PC<--DST R[rt]<---S; Mem dato<---MEM[S]; MEM[S]<--B; R[rt]<---dato;

Problema 2.a: Grafo de Estado IR<--MEM[PC]; PC<-PC+4 A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Z<---AopB si (Z) PC<--DST S<---AopB R[rd]<---S S<---A+ signext(inm16) dato<---MEM[S] R[rt]<---dato MEM[S]<--B

Problema 2.a: Rendimiento El diagrama de estados nos da el CPI por instrucción (y el camino crítico). Comparamos la máquina original a 50 Mhz con ésta que tiene un ciclo más largo: 40Mhz Tipo CPI1 CPI2 %inst CPI1x %inst CPI1x %inst ALU 4 3 40% 1.6 1.2 Load 5 4 30% 1.5 1.2 Store 4 4 10% 0.4 0.4 Branch 3 3 20% 0.6 0.6 CPI 1Medio= 4.1 CPI2 Medio= 3.4

Problema 2.b Diseñar el control de la máquina multiciclo suponiendo que, además de lo supuesto en el Problema 2, el cálculo de las direcciones efectivas se realizan en el mismo ciclo que el acceso a memoria. Esta máquina tiene un reloj de 25 Mhz. Comparar rendimientos. Paso Tipo R Load Store Beq Fetch IR<----MEM[PC]; PC<--PC+4 Decod A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Eje y S<---AopB; S<---A+ signext(inm16); S<---A+ signext(inm16); Z<---AopB Mem R[rd]<---S; dato<---MEM[S]; MEM[S]<--B; si (Z) PC<--DST R[rt]<---dato;

Problema 2.b: Grafo de Estado IR<--MEM[PC]; PC<-PC+4 A<-----R[rs]; B<-----R[rt]; DST<---PC+(signext(inm16)<<2) Z<---AopB si (Z) PC<--DST S<---AopB R[rd]<---S S<---A+ signext(inm16) dato<---MEM[S] R[rt]<---dato S<---A+ signext(inm16) MEM[S]<--B

Problema 2.b: Rendimiento El diagrama de estados nos da el CPI por instrucción (y el camino crítico). Comparamos la máquina original a 50 Mhz con ésta que tiene un ciclo más largo: 25Mhz Tipo CPI1 CPI2 %inst CPI1x %inst CPI1x %inst ALU 4 3 40% 1.6 1,2 Load 5 3 30% 1.5 0,9 Store 4 3 10% 0.4 0.3 Branch 3 3 20% 0.6 0.6 CPI 1Medio= 4.1 CPI2 Medio= 3

Problema 2.c: Conclusiones?? Cuales serán las mezclas de instrucciones que hagan más rápida a una de las máquinas respecto a las otras? M2 es 1,09 veces más rápida que M1 M2 es 1,6 veces más rápida que M3 M1 es 1,46 veces más rápida que M3 Tipo M1 M2 M3 T_ejec 82nseg 75nseg 120nseg CPI 4,1 4,5 3 Frecuencia 50Mhz 40Mhz 25Mhz Rendimiento 1/82 1/75 1/120