Intrucciones Principiosde Conjuntos de
Organización Computadoras de Organización 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 XX 000 en la parte más baja de la palabra. Word • “Big Endian ”: pone el byte cuya dirección es XX 000 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 MIPS 32 MIPS
La Arquitectura MIPS Arquitectura La 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) Loop: else PC ← PC+4
bne $5, $6, 16
31 0 000101 000101 000110 1111111111111011
Op Code fuente destino inmediato (6 bits) (5 bits) (5 bits) (16 bits) Instrucción del Tipo R: add
(Texto) add rd, rs, rt Regs[rd] ← Regs[rs] + Regs[rt] Ensamblado
31 0 (Hardware) 0 rs rt rd 0 0x20 Op Code fuente 1 fuente 2 destino función (6 bits) (5 bits) (5 bits) (5 bits) (6 bits) Ejemplo de add:
(Texto) add $7, $8, $9 Regs[rd] ← Regs[rs] + Regs[rt] Ensamblado
31 0
(Hardware) 0 01000 01001 00111 0 0x20
Op Code fuente 1 fuente 2 destino función (6 bits) (5 bits) (5 bits) (5 bits) (6 bits) Instrucción del Tipo R: sll
(Texto) sll rd, rt, shamt Regs[rd] ← Regs[rt] << shamt Ensamblado
31 0
(Hardware) 0 rt rd shamt 0
Op Code fuente destino despl. función (6 bits) (5 bits) (5 bits) (5 bits) (6 bits) Instrucción del Tipo J: j
(Texto) j target pc ← target Ensamblado
31 0
(Hardware) 2 target Op Code destino (6 bits) (26 bits) Instrucción del Tipo J: jal
(Texto) jal target Regs[31] ← pc pc ← target* Ensamblado
31 0
(Hardware) 3 target Op Code destino (6 bits) (26 bits) Instrucciones Aritmético Lógicas
add, addu, addi, addiu, sub and, andi, xor, xori, nor, or, ori clo, clz div (cociente en Lo, resto en Hi), divu mult, multu (resultado en Hi Lo) mul (especifica rdest) madd, maddu, msub, msubu (resultado en Hi Lo) sll, sllv, sra, srav, srl, srlv Instrucciones que manipulan constantes y de comparación
lui (load upper immediate)
slt, sltu, slti, sltiu (set) • Ejemplo slt: Instrucciones de branch
beq bgez, bgezal bgtz blez bltz, bltzal bne Instrucciones de jump
j (jump) jal (jump and link) jr (jump register ) jalr (jump and link register) Instrucciones de carga- almacenamiento
lb, lbu, lh, lhu, lw sb, sh, sw Instrucciones de movimiento de datos
mfhi, mflo mthi, mtlo movn movz Instrucción de llamada al sistema
eret syscall break Instrucción que no hace nada
nop Pseudoinstrucciones
Real instruction Name instruction syntax meaning translation Move move $rt,$rs addi $rt,$rs,0 R[rt]=R[rs] Clear clear $rt add $rt,$zero,$zero R[rt]=0 lui $at, LabelAddr[31:16]; Load Address la $at, LabelAddr ori $at,$at, $at = Label Address LabelAddr[15:0] lui $at, IMMED[31:16]; ori $at = 32 bit Immediate Load Immediate li $at, IMMED[31:0] $at,$at, IMMED[15:0] value slt $at,$rt,$rs; bne Branch if greater than bgt $rs,$rt,Label if(R[rs]>R[rt]) PC=Label $at,$zero,Label slt $at,$rs,$rt; bne Branch if less than blt $rs,$rt,Label if(R[rs]
Modelo de memoria Llamados a funciones MIPS Microprocessors Frequency Process Transistors Die Size Voltage D. cache I. cache Model Year Pin Count Power (W) L2 Cache L3 Cache (MHz) (µm) (millions) (mm 2) (V) (KB) (KB) R2000 8–16.67 1985 2.0 0.11 ? ? ? ? 32 64 None None 0-256 KB R3000 12–40 1988 1.2 0.11 66.12 145 4 ? 64 64 External None 1 MB R4000 100 1991 0.8 1.35 213 179 15 5 8 8 External None 1-4 MB R4400 100–250 1992 0.6 2.3 186 179 15 5 16 16 External None 512 KB R4600 100–133 1994 0.64 2.2 77 179 4.6 5 16 16 External None 512 KB R4650 133–180 1994 0.64 2.2? 77? 179 4.6? 5 16 16 External None R4700 100–200 1996 0.5 2.2? ? 179 ? ? 16 16 External none 1 MB R5000 150–200 1996 0.35 3.7 84 223 10 3.3 32 32 External None 4 MB R8000 75–90 1994 0.7 2.6 299 591+591 30 3.3 16 16 External None 512 KB– R10000 16 MB 150–250 1996 0.35, 0.25 6.7 299 599 30 3.3 32 32 external None 512 KB– R12000 16 MB 270–400 1998 0.25, 0.18 6.9 204 600 20 4 32 32 external None 0.25, 0.18, 3.3, 2.5, 256 KB 1 MB RM7000 250–600 1998 0.13 18 91 304 10, 6, 3 1.5 16 16 internal external 512 KB– R14000 16 MB 500–600 2001 0.13 7.2 204 527 17 ? 32 32 external None 512 KB– R16000 16 MB 700–1000 2002 0.11 ? ? ? 20 ? 32 32 external None 4-16 MB R24K 750+ 2003 65 nm ? 0.83 ? ? ? 64 64 external Sistemas basados en MIPS
Routers Cablemodem ADSL Smart Cards Impresoras laser Decodificadores PlaySation 2 Robots Celulares Arquitectura MIPS presente en los siguientes procesadores
IDT RC32438; ATI Xilleon; Alchemy Au1000, 1100, 1200; Broadcom Sentry5; RMI XLR7xx, Cavium Octeon CN30xx, CN31xx, CN36xx, CN38xx and CN5xxx; Infineon Technologies EasyPort , Amazon, Danube, ADM5120, WildPass, INCA IP, INCA IP2; Microchip Technology PIC32; NEC EMMA and EMMA2, NEC VR4181A, VR4121, VR4122, VR4181A, VR5432, VR5500; Oak Technologies Generation; PMC Sierra RM11200; QuickLogic QuickMIPS ESP; Toshiba Donau , Toshiba TMPR492x, TX4925, TX9956, TX7901. Supercomputadoras basadas en MIPS.
Estaciones de Trabajo Servidores Supercomputadoras gráficas
1990 1996 2005
Evolución SGI Supercomputadoras basadas en MIPS.
SGI Origin 2000 Supercomputadoras basadas en MIPS. Sircortex startup (2007)
Sircortex SC5832 CHIP (nodo): multinucleo 6 MIPS 64 Topologia Kautz graph Controlador de memoria crossbar interconnect DMA engine, Gigabit Ethernet y PCI Express en un chip que consume 10 watts Desempeño pico de 6 Gigaflops. Configuración tope (un solo gabinete): 972 nodos, total de 5832 nucleos MIPS64 y 8.2 teraFLOPS de desempeño pico. FIN