1 / 43

Verano 2004

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. Todas las instrucciones tardan tanto como la más lenta Ciclo de reloj es largo, pero CPI=1

mizell
Télécharger la présentation

Verano 2004

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Organización del Computador I VeranoProcesador MulticicloBasado en el capítulo 5 del libro de Patterson y Hennessy Verano 2004 Profesora Borensztejn

  2. Diseño monociclo • 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.

  3. Registro/memoria Registro/memoria Sistema Combinacional A Sistema Combinacional Registro/memoria Registro/memoria Sistema Combinacional B Registro/memoria Único ciclo Multiciclo 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.

  4. 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

  5. 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

  6. 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.

  7. 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

  8. 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 LecturaFetch/Decod/Eje. Fetch

  9. 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........

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

  11. 32 32 32 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 MUX BusA 32 32 BusB 32 MUX 4 Inm16 SignExt >>2

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

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

  14. 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

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

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

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

  18. 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

  19. 4o Paso:Load • Transferencias Lógicas (RTL) 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

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

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

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

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

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

  25. 4o Paso:STORE • Transferencias Lógicas (RTL) 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;

  26. 4o Paso:BEQ • Transferencias Lógicas (RTL) 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;

  27. 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;

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

  29. 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

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

  31. 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

  32. 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

  33. 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

  34. Máquina de Estados Finitos • Implementación: PCW Branch IoD WE PCsrc IRW W_src C o n t r o l l o g i c ALUop ALUselB O u t p u t s ALUselA RegW RegDst N S 3 N S 2 N S 1 I n p u t s N S 0 5 4 3 2 1 0 p p p p p p 3 2 1 0 O O O O O O S S S S e g i s t e r I n s t r u c t i o n 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

  35. 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

  36. 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

  37. 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;

  38. 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

  39. 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

  40. 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;

  41. 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

  42. 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

  43. 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 M2M3 T_ejec 82nseg 75nseg 120nseg CPI 4,1 4,5 3 Frecuencia 50Mhz 40Mhz 25Mhz Rendimiento 1/82 1/75 1/120

More Related