Organización De Computadoras
Total Page：16
File Type：pdf, Size：1020Kb
Organización de Computadoras Principios de Conjuntos de Intrucciones Clasifición de las ISA Secuencia de Código para C = A + B Stack Acumulador Registro Registro (Reg-Mem) (load-store) Push A Load A Load R1, A Load R1,A Push B Add B Add R3,R1,B Load R2,B Add Store C Store R3, C Add R3,R1,R2 Pop C Store R3,C Combinaciones de operandos en memoria y operandos totales en instrucciones de ALU Nro. de Máximo nro. Tipo de Ejemplos direcciones de de operandos arquitectura memoria permitidos 0 3 Registro-registro Alpha, ARM, MIPS, PowerPC, SPARC. 1 2 Registro- IBM 360/370, memoria Intel 80x86, Motorola 68000 2 2 Memoria- VAX Memoria 3 3 Memoria- VAX Memoria Ventajas y desventajas de los 3 tipos más comunes de computadoras del tipo registro de propósito general Tipo Ventajas Desventajas R-R (0,3) Simple, codificación con instrucciones de Conteo de instrucciones tamaño fijo, modelo de generación de más alto, programas más código simple, instrucciones toman grandes similares ciclos de reloj para su ejecución R-M (1,2) Se pueden acceder datos sin un load Los operandos no son separado primero. Tendencia a ser equivalentes (uno es facilmente codificado, destuido). Pocos bits disponibles para codificar el registro M-M (2,2) Código compacto. No desperdicia Gran variación en el o (3,3) registros como temporarios tamaño de instrucción. CPI muy variable. Cuello de botella en la memoria Direccionamiento de Memoria Direccionamiento por byte , acceso a: • Byte • Half word • Word • Double word Tópicos • Alineación • Orden • Litttle endian • Big endian Alineación de objetos en memoria Direccionamiento de Memoria Interpretación de las direcciones de memoria. Word • “Little Endian ”: pone el byte cuya dirección es XX000 en la parte más baja de la palabra. Word • “Big Endian ”: pone el byte cuya dirección es XX000 en la parte más alta de la palabra. Modos de Direccionamiento MIPS 32 1. Immediate addressing o p rs r t Im m e d ia te 2. Register addressing o p rs r t rd . funct R e g is te rs R e g is te r 3. Base addressing op rs rt Address M e m o r y R e g iste r + B y te H a lfw o r d W o rd 4. PC-relative addressing o p rs r t A d d r e s s M e m o r y PC + W o rd 5. Pseudodirect addressing o p A d d re s s M e m o r y PC W o rd Modos de Direccionamiento en MIPS 32, ejemplos Registro Inmediato Desplazamiento add $1, $2, $3 regs[1] regs[2] + regs[3] addi $1, $2, 35 regs[1] regs[2] + 35 lw $1, 35($2) regs[1] mem[regs[2] + 35] Modos de Direccionamiento en MIPS C code: g = h + A[8]; g in $s1, h in $s2, base address of A in $s3 Compiled MIPS code: Index 8 requires offset of 32 4 bytes per word lw $t0, 32($s3) #load word add $s1, $s2, $t0 Frecuencia de modos de direccionamiento (VAX, SPEC89) Número de bits de desplazamiento (Alpha, SPEC CPU2000) Uso de inmediatos (Alpha, SPEC CPU2000) Tipo y tamaño de operandos Generalmente lo implica el OpCode • Carácter • ASCII • Unicode • Enteros • Half word • Word • Coma flotante, precisión simple y doble • IEEE 754 • Decimal • BCD Operaciones en el conjunto de instrucciones Top 10 instrucciones en 80x86 Soporte multimedia para desktop RISC Instrucciones de control del flujo del programa Salto condicional (branch) Salto incondicional (jump) Llamado a procedimiento (call) Retorno de procedimiento (return) Modos de direccionamiento para instrucciones de control Relativas al PC Registro indirecto (dirección del salto no conocida en tiempo de compilación) Evaluación de las condiciones de los Branchs Frecuencia de los diferentes tipos de comparaciones Programando a nivel de la máquina Programa en MIPS 32 que calcula la suma de los cuadrados de los numeros de 0 a 100. Programando en lenguaje ensamblador (crudo) Da una sintaxis con mnemónicos para las instrucciones, registros y modos de direccionamiento. Programando en lenguaje ensamblador (con abstracciones) Agrega: directivas, labels, pseudoinstrucciones, modos de direccionamiento no soportados por el procesador . Proceso de producir un ejecutable Ensamblador Programa que traduce el código assembly a binario. Genera como salida un archivo objeto . Archivo objeto generado por un assembler en Unix Linker Enlaza los archivos objeto y genera el ejecutable. Resuelve las referencias a bibliotecas externas. Asigna las posiciones finales en memoria. Necesidad de mayores de abstracciones: lenguajes de alto nivel El compilador Generación de un ejecutable El Roll de los Compiladores Expectativas para aplicaciones del tipo de escritorio Arquitectura carga/almacenamiento Registros de propósito general Modos de direccionamiento • Desplazamiento • Inmediato Tipos de datos • Enteros, 8, 16, 32 y 64 bits • Coma flotante, IEEE 754 Instrucciones simples • load, store, add, subtract, move reg-reg, shift • Compare, branch, jump, call, return Codificación de instrucción fija La Arquitectura MIPS MIPS 32 La Arquitectura MIPS Conjunto de instrucciones simple L/S Diseñada para eficiencia del pipeline Eficiencia para el compilador La Arquitectura MIPS Registros • 32 registros de 32 bits: $0, $1, $2, $31 (int) • 32 registros de 32 bits: $f0, $f1, $f2, $f31 (fp) Tipos de datos • Bytes (8 bits), Half Word (16 bits), Words (32 bits) • Double words (fp) Modos de direccionamiento • Inmediato • Desplazamiento CPU, FPU y el coprocesador 0 Causa de excepciones El registro CAUSE Convención de uso de registros Registers Name Number Use Callee must preserve? $zero $0 constant 0 N/A $at $1 assembler temporary No values for function $v0–$v1 $2–$3 returns and expression No evaluation $a0–$a3 $4–$7 function arguments No $t0–$t7 $8–$15 temporaries No $s0–$s7 $16–$23 saved temporaries Yes $t8–$t9 $24–$25 temporaries No $k0–$k1 $26–$27 reserved for OS kernel No $gp $28 global pointer Yes $sp $29 stack pointer Yes $fp $30 frame pointer Yes $ra $31 return address N/A Ejemplo de un loop # Computa la suma de los elementos de un vector. Precondiciones en zona de datos: length es la longitud del vector de enteros array. Postcondiciones: el resultado queda en donde estaba la longitud del vector. .text .globl main main: addi $v0, $zero, 0 # v0 = resultado = 0 la $t0, length # t0 = address de length lw $t1, 0($t0) # t1 = length la $t4, array # t4 = address de array[0] addi $t1, $t1, -1 # t1 = indice del ultimo elemento del vector sll $t1, $t1, 2 # multiplico length por 4, t1 = address de array[length-1] loop: add $t3, $t4, $t1 lw $t2, 0($t3) # t2 = array[i] add $v0, $v0, $t2 # resultado += array[i] addi $t1, $t1, -4 # i-- test: slti $t9, $t1, 0 # if !(i<0) ... beq $t9, $zero, loop # ... go to loop nop sw $v0, 0($t0) # reemplaza length con resultado halt: beq $zero, $zero, halt nop .data length: .word 8 array: .word 9, 8, 7, 6, 5, 4, 3, 2 .text .globl main main: addi $v0, $zero, 0 # v0 = resultado = 0 #la $t0, length # t0 = address de length lui ori lw $t1, 0($t0) # t1 = length #la $t4, array # t4 = address de array[0] lui ori addi $t1, $t1, -1 # t1 = indice del ultimo elemento del vector sll $t1, $t1, 2 # multiplico length por 4, t1 = address de array[length - loop: add $t3, $t4, $t1 lw $t2, 0($t3) # t2 = array [i] add $v0, $v0, $t2 # resultado += array[i] addi $t1, $t1, -4 # i-- test: slti $t9, $t1, 0 # if !(i<0) ... beq $t9, $zero, loop # ... go to loop nop sw $v0, 0($t0) # reemplaza length con resultado halt: beq $zero, $zero, halt nop .data length: .word 8 array: .word 9, 8, 7, 6, 5, 4, 3, 2 Código sin pseudoinstrucciones Para el código anterior calcular: Cantidad de instrucciones del programa. Tamaño del código en bytes. Cantidad de instrucciones ejecutadas. Cantidad de bytes de instrucciones transferidos entre CPU y memoria. Cantidad de accesos a datos en memoria realizados. Cantidad de bytes de datos transferidos entre CPU y memoria . Cantidad total de bytes transferidos entre CPU y memoria. Para el código anterior calcular: Porcentaje de accesos a datos que son lectura. Porcentaje de accesos a memoria que son lectura. Clasificar a las instrucciones en los grupos: ALU, L/S, BRANCH, JUMP, FP. Calcular la frecuencia de ejecución de cada grupo. Calcular el porcentaje de saltos tomados. Calcular el CPI del código (usar CPI típicos de grupos) Calcular el tiempo de ejecución si la CPU corre a 100MHZ. Calcular el porcentaje de tiempo que la CPU ejecuta intrucciones de ALU. Para el código anterior calcular: Se propone llevar el CPI de las instrucciones de BRANCH a 1 (branchs tomados y no tomados). • Calcular el SPEEDUP total usando la ecuación de desempeño de CPU. • Calcular el SPEEDUP total usando la ley de Amdahl. Formatos de Instrucciones MIPS Instrucción del Tipo I: addi (Texto) addi rt, rs, imm regs[rt] ← regs[rs] + imm Ensamblado 31 0 (Hardware) 8 rs rt imm Op Code fuente destino inmediato (6 bits) (5 bits) (5 bits) (16 bits) Ejemplo de addi (Texto) addi $1, $2, 15 regs[1] ← regs[2] + 15 Ensamblado (Hardware) 001000 00010 00001 0000000000001111 Op Code fuente destino inmediato Instrucción del Tipo I: lw (Texto) lw rt, offset(rs) Regs[rt] ← Mem[Regs[rs] + imm] Ensamblado 31 0 (Hardware) 0x23 rs rt Offset Op Code fuente destino inmediato (6 bits) (5 bits) (5 bits) (16 bits) Ejemplo de lw (Texto) lw $3, 33($4) Regs[3] ← Mem[Regs[4] + 33] Ensamblado 31 0 (Hardware) 010111 00100 00011 0000000000100001 Op Code fuente destino inmediato (6 bits) (5 bits) (5 bits) (16 bits) Instrucción del Tipo I: bne (Texto) bne rs, rt, label if (Regs[rs] ≠ Regs[rt]) then PC ← PC+4+(Offsetx4) Ensamblado else PC ← PC+4 31 0 (Hardware) 5 rs rt Offset Op Code fuente destino inmediato (6 bits) (5 bits) (5 bits) (16 bits) Ejemplo de bne bne $5, $6, loop if (Regs[5] ≠ Regs[6]) then PC ← PC+4+(-5x4)