Un estudio de instrucciones

para computadora

Instrucciones: Lenguaje de la
computadora
Revisado y ampliado de las diapositivas
originales proporcionadas por MKP
Jeraquía de Lenguajes
Arquitectura
  Las computadoras
modernas utilizan
la arquitectura Von
Neumann (también
llamada concepto
de programa
almacenado)
  Fue derivado por
Von Neumann
(obviamente), John
Mauchly y Presper
Eckert.

3
La realidad ARM
Introducción
  Jerarquía de lenguajes de computadoras:
1. Aplicación con Lenguaje específico
(compilador Matlab)
2. Lenguaje de programación de alto nivel
(C ++, Java)
3. Lenguaje ensamblador (depende de la máquina)
4. Lenguaje de máquina (depende de la máquina)

5
Introducción (Cont.)

• No hay nada "debajo" del lenguaje de máquina,

solo hardware.
• El lenguaje de máquina es el único lenguaje que
entienden las computadoras (es decir, es nativo
del procesador)
• Imposible de leer para los humanos. Consta de
solo 0 y 1.
• 0001001111110000
6
Conjunto de Instrucciones
  El repertorio de instrucciones de una
computadora.
  Diferentes computadoras tienen diferentes
conjuntos de instrucciones
  Pero con muchos aspectos en común
  Las primeras computadoras tenían
conjuntos de instrucciones muy simples
  Implementación simplificada
  Muchas computadoras modernas también
tienen conjuntos de instrucciones simples
El conjunto de instrucciones MIPS
  Usado como ejemplo en todo libro.
  Stanford MIPS comercializado por MIPS
Technologies (www.mips.com)
  Gran parte del mercado núcleo embebido
  Aplicaciones en electrónica de consumo, equipos de
red / almacenamiento, cámaras, impresoras,…
  Típico de muchas ISAs modernas
  Consulte la tarjeta extraíble de datos de referencia de
MIPS y los apéndices B y E
 Operaciones aritméticas
• Sumar y restar, tres operandos
  Dos fuentes y un destino
add a, b, c # a gets b + c
• Todas las operaciones aritméticas tienen esta
forma
• Principio de diseño 1: la simplicidad favorece
la regularidad
  La regularidad simplifica la implementación
  La simplicidad permite un mayor rendimiento a

menor costo
Ejemplo aritmético
  Código C:
f = (g + h) - (i + j);

  Código MIPS compilado:

add t0, g, h # temp t0 = g + h
add t1, i, j # temp t1 = i + j
sub f, t0, t # f = t0 - t1
1

Chapter 2 — Instructions: Language of the Computer — 10

 Registrar operandos
  Registro de uso de instrucciones aritméticas
  MIPS tiene un archivo de registro de 32 × 32 bits
  Usado para datos a los que se accede con frecuencia
  Numerados del 0 al 31
  Datos de 32 bits denominados "palabra"
  Nombres de ensamblador
  $ t0, $ t1,…, $ t9 para valores temporales
  $ s0, $ s1,…, $ s7 para las variables guardadas
  Principio de diseño 2: cuanto más pequeño, más rápido
  c.f. memoria principal: millones de ubicaciones
Ejemplo de operando de registro
  Código C:
f = (g + h) - (i + j);
  f, …, j in $s0, …, $s4
  Código MIPS compilado
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
Operandos de memoria
  Memoria principal utilizada para datos compuestos
  Matrices, estructuras, datos dinámicos
  Aplicar operaciones aritméticas
  Cargar valores de la memoria en registros
  Almacenar el resultado del registro en la memoria
  La memoria tiene una dirección de byte
  Cada dirección identifica un byte de 8 bits
  Las palabras están alineadas en la memoria
  La dirección debe ser múltiplo de 4
  MIPS es Big Endian
  Byte más significativo al menos la dirección de una palabra
  c.f. Pequeño Endian: byte menos significativo al menos
dirección
Ejemplo 1 de operando de memoria
  Código C:
g = h + A[8];
  g in $s1, h in $s2, dirección base de A en $ s3
  Código MIPS compilado:
  El índice 8 requiere una offset de 32
  4 bytes por palabra
lw $t0, 32($s3) # carga palabra
add $s1, $s2, $t0
offset Registro base
Ejemplo 2 de operando de memoria
  Código C:
A[12] = h + A[8];
  h en $s2, dirección base de A en $ s3
  Código MIPS compilado:
  El índice 8 requiere offset de 32
lw $t0, 32($s3) # carga Palabra
add $t0, $s2, $t0
sw $t0, 48($s3) # almacena palabra
Registros frente a memoria
  Los registros son más rápidos de acceder
que la memoria
  Operar con datos de memoria requiere
cargas y almacena
  Más instrucciones para ejecutar
 El compilador debe usar registros para
variables tanto como sea posible
  Solo dividir en la memoria para las variables

utilizadas con menos frecuencia

  ¡La optimización del registro es importante!
 Operandos inmediatos
  Datos constantes especificados en una instrucción
addi $s3, $s3, 4
  Sin restar instrucción inmediata
  Solo usa una constante negativa
addi $s2, $s1, -1
 Principio de diseño 3: hacer que el caso común
sea rápido
  Las pequeñas constantes son comunes
  El operando inmediato evita una instrucción de carga
El cero constante
  El registro MIPS 0 ($ cero) es la constante 0
  No se puede sobrescribir
  Útil para operaciones comunes
  Por ejemplo, moverse entre registros
add $t2, $s1, $zero
Enteros binarios sin signo
  Dado un número de n bits

  Rango: 0 a +2n – 1
  Ejemplo

  0000 0000 0000 0000 0000 0000 0000 10112

= 0 + … + 1×23 + 0×22 +1×21 +1×20
= 0 + … + 8 + 0 + 2 + 1 = 1110
  Usa 32 bits
  0 a +4,294,967,295
Extensión de signo
  Representar un número usando más bits
  Conservar el valor numérico
  En conjunto de instrucciones MIPS
  addi: extender valor inmediato
  lb, lh: extender byte cargado / media palabra
  beq, bne: extender el desplazamiento
  Replica el bit de señal a la izquierda
  c.f. valores sin signo: extender con 0s
  Ejemplos: de 8 bits a 16 bits
  +2: 0000 0010 => 0000 0000 0000 0010
  –2: 1111 1110 => 1111 1111 1111 1110
Representando instrucciones
  Las instrucciones están codificadas en binario
  Código de máquina llamado
  Instrucciones MIPS
  Codificado como palabras de instrucción de 32 bits
  Pequeño número de formatos que codifican código de
operación (código de operación),
… números de registro,
  ¡Regularidad!

  Números de registro
  $t0 – $t7 son reg’s 8 – 15
  $t8 – $t9 son reg’s 24 – 25
  $s0 – $s7 son reg’s 16 – 23
Instrucciones de formato MIPS R
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

  Campos de instrucción
  op: código de operación (código de operación)
  rs: número de registro de la primera fuente

  rt: número de registro de la segunda fuente

  rd: número de registro de destino

  shamt: cantidad de cambio (00000 por ahora)

  funct: código de función (extiende el código de

operación)
Ejemplo de formato R
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

add $t0, $s1, $s2

special $s1 $s2 $t0 0 add

0 17 18 8 0 32

000000 10001 10010 01000 00000 100000

000000100011001001000000001000002 = 0232402016
Hexadecimal
  Base 16
  Representación compacta de cadenas de bits
  4 bits por dígito hexadecimal

0 0000 4 0100 8 1000 c 1100

1 0001 5 0101 9 1001 d 1101
2 0010 6 0110 a 1010 e 1110
3 0011 7 0111 b 1011 f 1111

  Ejemplo: eca8 6420

1110 1100 1010
  0110 0100 0010 0000
1000
Instrucciones de formato MIPS I
op rs rt constante o dirección
6 bits 5 bits 5 bits 16 bits

  Instrucciones inmediatas de aritmética y carga / almacenamiento

  rt: número de registro de origen o destino

  Constante: –215 a +215 – 1

  dirección: desplazamiento agregado a la dirección base en
rs
  Principio de diseño 4: un buen diseño exige buenos
compromisos
Los diferentes formatos complican la decodificación, pero
 

permiten instrucciones de 32 bits de manera uniforme

  Mantenga los formatos lo más similares posible
Computadoras de programa almacenado
El panorama   Instrucciones representadas en
binario, como datos
  Instrucciones y datos
almacenados en la memoria
  Los programas pueden operar
en programas
  p. ej., compiladores, enlazadores, ...
  La compatibilidad binaria
permite que los programas
compilados funcionen en
diferentes computadoras
  ISAs estandarizadas
Operaciones lógicas
  Instrucciones para la manipulación bit a bit
Operación C Java MIPS
Desplazar a la
izquierda << << sll
Desplazar a la
derecha >> >>> srl
AND bit a bit & & and, andi
OR bit a bit | | or, ori
NOT bit a bit ~ ~ nor

 Útil para extraer e insertar grupos de bits en

una palabra
Operaciones de desplazamiento
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

  shamt: cuántas posiciones cambiar

  Desplazamiento lógico a la izquierda

  Desplazar a la izquierda y rellenar con 0 bits

  sll por i bits multiplicar por 2i

  Desplazamiento lógico a la derecha

  Desplazar a la derecha y rellenar con 0 bits
  srl por i bits dividir por 2i (solo sin signo)
Operationes AND
  Útil para enmascarar bits en una palabra
  Seleccione algunos bits, borre otros a 0
and $t0, $t1, $t2

$t2 0000 0000 0000 0000 00 1101

1 1100 0000
00
$t1 0000 0000 0000 0000 11 1100
1 0000 0000
00
$t0 0000 0000 0000 0000 00 1
1100 0000 0000
00
 Operationes OR
  Útil para incluir bits en una palabra
  Establezca algunos bits en 1, deje otros sin cambios
or $t0, $t1, $t2

$t2 0000 0000 0000 0000 0000 1101 1100 0000

$t1 0000 0000 0000 0000 0011

00 1100 0000 0000

$t0 0000 0000 0000 0000 0011

00 1101 1100
0000
Operationes NOT
  Útil para invertir bits en una palabra
  Cambiar de 0 a 1 y de 1 a 0
  MIPS tiene instrucción NOR de 3 operandos
  a NOR b == NOT ( a OR b )
nor $t0, $t1, $zero Registro 0: siempre
leer como cero

$t1 0000 0000 0000 0000 0011 1100 0000 0000

$t0 1111 1111 1111 1111 1100 0011 1111 1111

Operaciones condicionales
 Bifurca a una instrucción etiquetada si una
condición es verdadera
  De lo contrario, continúe secuencialmente
  beq rs, rt, L1
  Si (rs == rt) bifurca a la instrucción etiquetada L1;
  bne rs, rt, L1
  Si (rs != rt) bifurca a la instrucción etiquetada L1;
  j L1
salto incondicional a la instrucción etiquetada como
 

L1
Compilación de declaración if
  Código C:
if (i==j) f = g+h;
else f = g-h;
  f, g, … in $s0, $s1, …
  Código MIPS compilado:
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit: … Ensamblador calcula direcciones
Compilación de declaración de bucle
  Código C:
while (save[i] == k) i += 1;
  i en $s3, k en $s5, dirección se guarda en $s6
  Código MIPS compilado:
Loop: sll $t1, $s3, 2
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
Exit: …
Bloques básicos
 Un bloque básico es una secuencia de
instrucciones con
  Sin bifurcaciones incrustadas (excepto al final)
  Sin objetivos de destino (excepto al principio)

  Un compilador identifica los

bloques básicos para la
optimización.
  Un procesador avanzado

puede acelerar la ejecución

de bloques básicos
Diseño de instrucción de bifurque
  ¿Por qué no blt, bge, etc.?
  Hardware para <, ≥,… más lento que =, ≠

La combinación con el bifurque implica más trabajo

 

por instrucción, lo que requiere un reloj más lento

  ¡Todas las instrucciones penalizadas!

  beq y bne son el caso común

  Este es un buen compromiso de diseño
Procedimiento de llamada
  Pasos requeridos
1. Colocar parámetros en registros
2. Transferir el control al procedimiento
3. Adquirir almacenamiento para el
procedimiento
4. Realizar las operaciones del procedimiento.
5. Colocar el resultado en el registro para la
persona que llama
6. Regresar al lugar de llamada
Instrucciones para el procedimiento call
  Procedimiento call: saltar y enlazar
jal ProcedureLabel
  Dirección de la siguiente instrucción puesta en $ra
  Salta a la dirección de destino

  Procedimiento retorno: registro de salto

jr $ra
  Copia $ra al contador del programa
  También se puede utilizar para saltos calculados.

  por ejemplo, para declaraciones de caso / cambio

 Datos locales en la pila

  Datos locales asignados por el destinatario de la llamada

  por ejemplo, C variables automáticas
  Marco de procedimiento (registro de activación)
 Utilizado por algunos compiladores para administrar el
almacenamiento de la pila
 Disposición de la memoria
  Texto: código de programa
  Datos estáticos: variables
globales
  por ejemplo, variables
estáticas en C, matrices
constantes y cadenas
  $gp inicializado para abordar el
permiso ± compensaciones en este
segmento
  Datos dinámicos: montón
  Por ejemplo, malloc en C, new en Java
  Pila: almacenamiento automático
Datos de caracteres
  Conjuntos de caracteres codificados por bytes
  ASCII: 128 caracteres
  95 gráfico, 33 control
  Latin-1: 256 caracteres
  ASCII, +96 caracteres gráficos más
  Unicode: Conjunto de caracteres de 32 bits
  Utilizado en Java, caracteres anchos
…de C ++,
  La mayoría de los alfabetos del mundo, además
de los símbolos.
  UTF-8, UTF-16: codificaciones de longitud

variable
 Operaciones Byte / Halfword
  Podría usar operaciones bit a bit
  Byte / Halfword MIPS carga / almacenamiento

  El procesamiento de cadenas es un caso común

lb rt, offset(rs) lh rt, offset(rs)
  El signo se extiende a 32 bits en rt
lbu rt, offset(rs) lhu rt, offset(rs)
  Cero se extiende a 32 bits en rt
sb rt, offset(rs) Sh rt, offset(rs)
 Almacenar solo el byte / media palabra más a
la derecha
Ejemplo de copia de cadena
  Código C (nativo):
  Cadena terminada en nulo
void strcpy (char x[], char y[])
{ int i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
  Direcciones de x, y en $a0, $a1

  i en $s0
Ejemplo de copia de cadena
  Código MIPS
strcpy:
addi $sp, $sp, -4 # ajustar la pila para 1 item
sw $s0, 0($sp) # salvar $s0
add $s0, $zero, $zero # i = 0
L1: add $t1, $s0, $a1 # dirección de y[i] en $t1
lbu $t2, 0($t1) # $t2 = y[i]
add $t3, $s0, $a0 # dirección de x[i] en $t3
sb $t2, 0($t3) # x[i] = y[i]
beq $t2, $zero, L2 # sale del bucle si y[i] == 0
addi $s0, $s0, 1 # i = i + 1
j L1 # siguiente iteración del bucle
L2: lw $s0, 0($sp) # Restaurar guardado $s0
addi $sp, $sp, 4 # sacar 1 artículo de la pila
jr $ra # y volver
 Constantes de 32 bits
  La mayoría de las constantes son pequeñas
  16 bits es suficiente inmediata
  Para la constante ocasional de 32 bits
lui rt, constante
  Copia constante de 16 bits a 16 bits izquierdos de rt
  Borra los 16 bits de la derecha de rt a 0

lhi $s0, 61 0000 0000 0111 1101 0000 0000 0000 0000

ori $s0, $s0, 2304 0000 0000 0111 1101 0000 1001 0000 0000
Direccionamiento de rama
  Las instrucciones de rama especifican
  Código de operación, dos registros, dirección de destino
  La mayoría de los objetivos de las ramificaciones son ramas cerca
  Hacia adelante o hacia atrás

op rs rt constante o dirección
6 bits 5 bits 5 bits 16 bits

  Direccionamiento relativo a PC
  Dirección de destino = PC + desplazamiento × 4
  PC ya incrementado en 4 en este momento
Direccionamiento de salto
 Los destinos Jump (j y jal) pueden estar en
cualquier parte del segmento de texto
  Codificar la dirección completa en la instrucción

op dirección
6 bits 26 bits

  (Pseudo) Direccionamiento de salto directo

  Dirección de destino = PC31…28:(dirección x 4)
Ejemplo de direccionamiento de destino
  Código de bucle del ejemplo anterior
Asumir bucle en la ubicación
 
80000
Loop: sll $t1, $s3, 2 80000 0 0 19 9 4 0
add $t1, $t1, $s6 80004 0 9 22 9 0 32
lw $t0, 0($t1) 80008 35 9 8 0
bne $t0, $s5, Exit 80012 5 8 21 2
addi $s3, $s3, 1 80016 8 19 19 1
j Loop 80020 2 20000
Exit: … 80024
 Ramificando muy lejos
 Si el destino de la rama está demasiado lejos
para codificar con un desplazamiento de 16 bits, el
ensamblador reescribe el código
t Ejemplo

beq $s0,$s1, L1
↓
bne $s0,$s1, L2
j L1
L2: …
Resumen del modo de direccionamiento
Sincronización
  Dos procesadores que comparten un área de memoria
  P1 escribe, luego P2 lee
  Carrera de datos si P1 y P2 no se sincronizan
  El resultado depende del orden de los accesos
  Se requiere soporte de hardware
  Operación de memoria atómica de lectura / escritura
 No se permite ningún otro acceso a la ubicación entre
lectura y escritura
  Podría ser una sola instrucción
  Por ejemplo, intercambio atómico de registro ↔ memoria
  O un par atómico de instrucciones
Sincronización en MIPS
  Carga vinculada: ll rt, offset(rs)
  Guardado condicional: sc rt, offset(rs)
  Tiene éxito si la ubicación no ha cambiado desde el ll
  Devuelve 1 en rt
  Falla si se cambia la ubicación
  Devuelve 0 en rt

  Ejemplo: intercambio atómico (para probar / establecer la variable de bloqueo)

try: add $t0,$zero,$s4 ; copiar valor de cambio
ll $t1,0($s1) ; carga vinculada
sc $t0,0($s1) ; almacenar condicional
beq $t0,$zero,try ; La rama falla
add $s4,$zero,$t1 ; poner el valor de carga en
$s4
Traducción y puesta en
marcha
Muchos compiladores producen
módulos de objetos directamente

Enlace estático
Pseudoinstrucciones de ensamblador
  La mayoría de las instrucciones del ensamblador
representan instrucciones de la máquina uno a uno

 Pseudoinstrucciones: invenciones de la imaginación del

ensamblador
move $t0, $t1 → add $t0, $zero, $t1
blt $t0, $t1, L → slt $at, $t0, $t1
bne $at, $zero, L
  $at (registro 1): ensamblador temporal
Producir un módulo de objeto
  El ensamblador (o compilador) traduce el
programa en instrucciones de máquina
  Proporciona información para construir un
programa completo a partir de las piezas.
  Encabezado: contenido descrito del módulo de objeto
  Segmento de texto: instrucciones traducidas
  Segmento de datos estáticos: datos asignados durante la

vida útil del programa

  Información de reubicación: para contenidos que dependen

de la ubicación absoluta del programa cargado

  Tabla de símbolos: definiciones globales y referencias externas

  Información de depuración: para asociar con el código fuente

Vincular módulos de objetos
  Produce una imagen ejecutable.
1. Fusiona segmentos
2. Resolver etiquetas (determinar sus
3. direcciones) Parchear referencias externas y
dependientes de la ubicación
  Podría dejar dependencias de ubicación para
que las arregle un cargador de reubicación
  Pero con la memoria virtual, no es necesario
hacer esto
  El programa se puede cargar en una ubicación

absoluta en el espacio de memoria virtual

Cargando un programa
  Cargar desde el archivo de imagen en el disco a la memoria
1.Leer el encabezado para determinar el tamaño de
los segmentos
2. Crea un espacio de direcciones virtual
3. Copiar texto y datos inicializados en la memoria
  O configure las entradas de la tabla de páginas para que se puedan generar errores

4. Configurar argumentos en la pila

5. Inicializar registros (incluidos $sp, $fp, $gp)
6. Saltar a la rutina de inicio
  Copia argumentos a $ a0, ... y llama a main
  Cuando main regresa, salga de syscall
 Vinculación dinámica
  Solo vincular / cargar procedimiento de biblioteca
cuando se llama
 Requiere que el código de procedimiento sea
reubicable
  Evita la hinchazón de la imagen causada por el enlace

estático de todas las bibliotecas a las que se hace

referencia (transitivamente)
  Recoge automáticamente nuevas versiones de la

biblioteca
Enlace perezoso

Mesa de Indirección

Stub: carga el ID de la
rutina, salta al
enlazador / cargador

Código del vinculador /

cargador

Código mapeado
dinámicamente
 Inicio de aplicaciones Java

Conjunto de
instrucciones portátil
simple para la JVM

Compila códigos
Interprete
de bytecodes
"calientes" en
bytecodes
código nativo para
la máquina host
 Ejemplo de ordenación en C
  Ilustra el uso de instrucciones de montaje
para una función de clasificación de burbujas C
  Procedimiento de intercambio (hoja)

void swap(int v[], int k)

{
int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
  v en $a0, k en $a1, temp en $t0
El procedimientos de intercambio
swap: sll $t1, $a1, 2 # $t1 = k * 4
add $t1, $a0, $t1 # $t1 = v+(k*4)
# (dirección de v[k])
lw $t0, 0($t1) # $t0 (temp) = v[k]
lw $t2, 4($t1) # $t2 = v[k+1]
sw $t2, 0($t1) # v[k] = $t2 (v[k+1])
sw $t0, 4($t1) # v[k+1] = $t0 (temp)
jr $ra # volver a llamar a la rutina
El procedimiento de orden en C
  No hoja (intercambio de llamadas)
void sort (int v[], int n)
{
int i, j;
for (i = 0; i < n; i += 1) {
for (j = i – 1;
j >= 0 && v[j] > v[j + 1];
j -= 1) {
swap(v,j);
}
}
}
  v en $a0, k en $a1, i en $s0, j en $s1
El cuerpo del procedimiento
move $s2, $a0 # save $a0 into $s2 Mover
move $s3, $a1 # save $a1 into $s3 parámetros
move $s0, $zero # i = 0
Bucle
for1tst: slt $t0, $s0, $s3 # $t0 = 0 if $s0 ≥ $s3 (i ≥ n) exterior
beq $t0, $zero, exit1 # go to exit1 if $s0 ≥ $s3 (i ≥ n)
addi $s1, $s0, –1 # j = i – 1
for2tst: slti $t0, $s1, 0 # $t0 = 1 if $s1 < 0 (j < 0)
bne $t0, $zero, exit2 # go to exit2 if $s1 < 0 (j
< 0) Bucle interior
sll $t1, $s1, 2 # $t1 = j * 4
add $t2, $s2, $t1 # $t2 = v + (j * 4)
lw $t3, 0($t2) # $t3 = v[j]
lw $t4, 4($t2) # $t4 = v[j + 1]
slt $t0, $t4, $t3 # $t0 = 0 if $t4 ≥ $t3
beq
move $t0,
$a0, $zero,
$s2 exit2 #
# go
1stto exit2
param ofif $t4is
swap ≥ $t3
v (old $a0) Pase
move $a1, $s1 # 2nd param of swap is j params
y llame
jal swap # call swap procedure
addi $s1, $s1, –1 # j –= 1 Bucle interior
j for2tst # jump to test of inner loop
exit2: addi $s0, $s0, 1 # i += 1 Bucle
j for1tst # jump to test of outer loop exterior
El procedimiento completo
sort: addi $sp,$sp, –20 # make room on stack for 5 registers
sw $ra, 16($sp) # save $ra on stack
sw $s3,12($sp) # save $s3 on stack
sw $s2, 8($sp) # save $s2 on stack
sw $s1, 4($sp) # save $s1 on stack
sw $s0, 0($sp) # save $s0 on stack
… # procedure body
…
exit1: lw $s0, 0($sp) # restore $s0 from stack
lw $s1, 4($sp) # restore $s1 from stack
lw $s2, 8($sp) # restore $s2 from stack
lw $s3,12($sp) # restore $s3 from stack
lw $ra,16($sp) # restore $ra from stack
addi $sp,$sp, 20 # restore stack pointer
jr $ra # return to calling routine
Efecto de la optimización del compilador
Compilado con gcc para Pentium 4 en Linux
Efecto del lenguaje y el algoritmo
Lecciones aprendidas
  El recuento de instrucciones y el IPC no son
buenos indicadores de rendimiento de forma
aislada
  Las optimizaciones del compilador son sensibles
al algoritmo
  El código compilado de Java / JIT es
significativamente más rápido que el interpretado
por JVM
  Comparable a C optimizado en algunos casos
  ¡Nada puede arreglar un algoritmo tonto!
Arreglos vs. Punteros
  La indexación de arreglos implica
  Multiplicar el índice por el tamaño del elemento
  Agregar a la dirección base del arreglo

  Los punteros corresponden directamente a

las direcciones de memoria
  Puede evitar la complejidad de la indexación
 Ejemplo: limpieza y arreglo
clear1(int array[], int size) { clear2(int *array, int size) {
int i; int *p;
for (i = 0; i < size; i += 1) for (p = &array[0]; p < &array[size];
array[i] = 0; p = p + 1)
} *p = 0;
}

move $t0,$zero # i = 0 move $t0,$a0 # p = & array[0]

loop1: sll $t1,$t0,2 # $t1 = i * 4 sll $t1,$a1,2 # $t1 = size * 4
add $t2,$a0,$t1 # $t2 = add $t2,$a0,$t1 # $t2 =
# &array[i] # &array[size]
sw $zero, loop2: sw $zero,0($t0) # Memory[p] = 0
0($t2) # array[i] = 0 addi $t0,$t0,4 # p = p + 4
addi $t0,$t0,1 slt $t3,$t0,$t2 # $t3 =
# i = i + 1
#(p<&array[siz
slt e])
$t3,$t0,$a1 # $t3 =
bne $t3,$zero,loop2 # if (…)
#
(i < size) # goto loop2
bne
$t3,$zero,loop1 # if (…)
# goto loop1
Comparación de Arreglos vs. Ptr.
  Multiplica "fuerza reducida" para cambiar
  La versión de arreglos requiere un cambio

para estar dentro del bucle

  Parte del cálculo del índice para i incrementado
  c.f. puntero incremental

  El compilador puede lograr el mismo efecto

que el uso manual de punteros
  Eliminación de variables de inducción
  Es mejor hacer que el programa sea más claro y
seguro
 Similitudes ARM y MIPS
  ARM: el núcleo integrado más popular
  Conjunto de instrucciones básicas similares a las de MIPS
ARM MIPS
Fecha anunciada 1985 1985
Tamaño de la instrucción 32 bits 32 bits
Espacio de dirección 32-bit plano 32-bit plano
Alineación de datos Alineado Alineado
Modos de direccionamiento de datos 9 3
Registros 15 × 32-bit 31 × 32-bit
entrada y salida Memoria Memoria
asignada asignada
 Comparar y bifurcar en ARM
  Utiliza códigos de condición para el resultado de
una instrucción aritmética / lógica
  Negativo, cero, acarreo, desbordamiento
  Compare las instrucciones para establecer códigos
de condición sin conservar el resultado
  Cada instrucción puede ser condicional
  Los 4 primeros bits de la palabra de instrucción: valor
de condición
  Puede evitar ramificaciones en instrucciones únicas
Codificación de instrucciones
 El Intel x86 ISA
  Evolución con compatibilidad con versiones anteriores
  8080 (1974): microprocesador de 8 bits
  Acumulador, más 3 pares de registros de índice
  8086 (1978): extensión de 16 bits a 8080
  Conjunto de instrucciones complejas (CISC)
  8087 (1980): coprocesador de punto flotante
  Agrega instrucciones FP y pila de registros
  80286 (1982): direcciones de 24 bits, MMU
  Mapeo y protección de memoria segmentada
  80386 (1985): extensión de 32 bits (ahora IA-32)
  Modos y operaciones de direccionamiento adicionales
  Asignación de memoria paginada y segmentos
El Intel x86 ISA
  Mayor evolución ...…
  i486 (1989): cachés en chip y FPU canalizados
  Competidores compatibles: AMD, Cyrix,…
  Pentium (1993): ruta de datos superescalar de 64 bits
  Las versiones posteriores agregaron instrucciones MMX (Multi-
Media eXtension)
  El infame error de FDIV
  Pentium Pro (1995), Pentium II (1997)
  Nueva microarquitectura (ver Colwell, The Pentium Chronicles)
  Pentium III (1999)
  Agregado SSE (Streaming SIMD Extensions) y registros
asociados
  Pentium 4 (2001)
  Nueva microarquitectura
  Instrucciones SSE2 agregadas
El Intel x86 ISA
  Y además……
  AMD64 (2003): arquitectura extendida a 64 bits
  EM64T – Tecnología de memoria extendida 64 (2004)
  AMD64 adoptado por Intel (con mejoras)
  Se agregaron instrucciones SSE3
  Intel Core (2006)
  Se agregaron instrucciones SSE4, soporte de máquina virtual
  AMD64 (anunciado en 2007): instrucciones SSE5
  Intel se negó a seguir, en cambio…
  Advanced Vector Extension (anunciada en 2008)
  Registros SSE más largos, más instrucciones
  Si Intel no ampliara la compatibilidad, ¡sus
competidores lo harían!
  Elegancia técnica ≠ Éxito en el mercado
Registros x86 básicos
Modos básicos de direccionamiento x86
  Dos operandos por instrucción
Operando de origen / destino Operando de segunda fuente

Registro Registro
Registro Immediato
Registro Memoria
Memoria Registro
Memoria Immediato

  Modos de direccionamiento de memoria

  Dirección en el registro
  Dirección = Rbase + desplazamiento
  Dirección = Rbase + 2scale × Rindex (escala = 0, 1, 2, or 3)
  Dirección = Rbase + 2scale × Rindex + desplazamiento
Codificación de instrucciones X86
 Codificación de
longitud variable
  Los bytes de sufijo
especifican el modo de
direccionamiento
  Los bytes de prefijo

modifican la operación
  Longitud del operando,
repetición, bloqueo, …
Implementación de IA-32
  El conjunto de instrucciones complejas
dificulta la implementación
  El hardware traduce las instrucciones en

microoperaciones más sencillas

  Instrucciones sencillas: 1–1
  Instrucciones complejas: 1 – muchas

  Micro motor similar a RISC

  La participación de mercado hace que esto sea

económicamente viable
  Rendimiento comparable al RISC
 Los compiladores evitan instrucciones
complejas
Falacias
  Instrucción poderosa ⇒ mayor rendimiento
  Se requieren menos instrucciones
  Pero las instrucciones complejas son difíciles de implementar
  Puede ralentizar todas las instrucciones, incluidas las sencillas
  Los compiladores son buenos para hacer código rápido a partir
de instrucciones simples
  Utilice código de ensamblaje para un alto rendimiento
  Pero los compiladores modernos son mejores para tratar con
procesadores modernos
  Más líneas de código ⇒ más errores y menos
productividad
Falacias
 Compatibilidad con versiones anteriores ⇒ el
conjunto de instrucciones no cambia
  Pero acumulan más instrucciones

conjunto de instrucciones
x86
Trampas
  Las palabras secuenciales no están en
direcciones secuenciales
  ¡Incrementar en 4, no en 1!
  Mantener un puntero a una variable
automática después de que regrese el
procedimiento
  por ejemplo, devolviendo el puntero a través de un
argumento
  El puntero se vuelve inválido cuando se abre la

pila
Observaciones finales
  Criterios de diseño
1. La sencillez favorece la regularidad
2. Cuanto más pequeño es más rápido
3. Acelere el caso común
4. Un buen diseño exige buenos compromisos
  Capas de software / hardware
  Compilador, ensamblador, hardware
  MIPS: típico de RISC ISA
  c.f. x86
 Observaciones finales
  Medir las ejecuciones de instrucciones MIPS
en programas de referencia
  Considere hacer que el caso común sea rápido
  Considere compromisos

Clase de instrucción Ejemplos de MIPS SPEC2006 Int SPEC2006 FP

Aritmética add, sub, addi 16% 48%
Transferencia lw, sw, lb, lbu, 35% 36%
de datos lh, lhu, sb, lui
Lógica and, or, nor, andi, 12% 4%
ori, sll, srl
Cond. Rama beq, bne, slt, 34% 8%
slti, sltiu
Salto j, jr, jal 2% 0%