Organización del Organización del ComputadorComputador

CPU (ISA)– Conjunto de CPU (ISA)– Conjunto de Instrucciones de la ArquitecturaInstrucciones de la Arquitectura

Computador

MemoriaPrincipal

EntradaSalida

Sistema deinterconexión

periféricos

Líneas decomunicación

UnidadCentral deProceso

CPU

Computador

Estructura (computadora)Estructura (computadora)

Computer UnidadAritmética y

Lógica

Unidadde

Control

InterconexiónInterna de la CPU

Registros

CPU

I/O

Memory

SystemBus

CPU

Estructura (CPU)Estructura (CPU)

Estructura de una máquinaEstructura de una máquina von Neumann von Neumann

Ciclo de EjecuciónCiclo de Ejecución

1.1. UC obtiene la próxima instrucción de UC obtiene la próxima instrucción de memoria (usando el registro PC).memoria (usando el registro PC).

2.2. Se incrementa el PC.Se incrementa el PC.

3.3. La instrucción es decodificada a un La instrucción es decodificada a un lenguaje que entiende la ALU.lenguaje que entiende la ALU.

4.4. Obtiene de memoria los operandos Obtiene de memoria los operandos requeridos por la operación.requeridos por la operación.

5.5. La ALU ejecuta y deja los resultados La ALU ejecuta y deja los resultados en registros o en memoria.en registros o en memoria.

6.6. Repetir paso 1.Repetir paso 1.

Los niveles de una computadoraLos niveles de una computadora

ISAISA Nivel de Lenguaje de Máquina (Instruction Set Nivel de Lenguaje de Máquina (Instruction Set

Architecture).Architecture). Límite entre Hardware-Software.Límite entre Hardware-Software. Es lo que vemos como programadoresEs lo que vemos como programadores Define: Define:

Cómo se representan, cómo se almacenan, y cómo Cómo se representan, cómo se almacenan, y cómo se acceden los datos,se acceden los datos,

Qué operaciones se pueden realizar con ellos,Qué operaciones se pueden realizar con ellos, Cómo se codifican estas operacionesCómo se codifican estas operaciones

No importa la implementación interna (lógica No importa la implementación interna (lógica combinatoria y demás detalles de hardware).combinatoria y demás detalles de hardware).

Métricas de una ISAMétricas de una ISA

Cantidad de memoria que un programa Cantidad de memoria que un programa requiere.requiere.

Complejidad del conjunto de instrucciones Complejidad del conjunto de instrucciones (por ejemplo RISC vs CISC).(por ejemplo RISC vs CISC).

Longitud de las instrucciones.Longitud de las instrucciones.Cantidad total de instrucciones.Cantidad total de instrucciones.

¿Cómo se representan los datos?¿Cómo se representan los datos?

Tipos de datosTipos de datosEnteros (8, 16, ó 32 bits; complemento a 2).Enteros (8, 16, ó 32 bits; complemento a 2).Big endian o Little endian.Big endian o Little endian.Punto Flotante.Punto Flotante.¿BCD, ASCII, UNICODE?¿BCD, ASCII, UNICODE?

Little vs Big endianLittle vs Big endian

““endianendian” se refiere a la forma en que la ” se refiere a la forma en que la computadora guarda datos multibyte.computadora guarda datos multibyte.

Por ejemplo cuando se guarda un entero Por ejemplo cuando se guarda un entero de dos bytes en memoria:de dos bytes en memoria:- “- “Little endianLittle endian”: el byte en una posición de ”: el byte en una posición de memoria menor, es menos significativo.memoria menor, es menos significativo.- “- “Big endianBig endian”: el byte en una posición de ”: el byte en una posición de memoria menor, es el más significativo.memoria menor, es el más significativo.

Little vs Big endianLittle vs Big endian Ejemplo: entero de dos bytes, Byte 0 menos Ejemplo: entero de dos bytes, Byte 0 menos

significativo, Byte 1 más significativo.significativo, Byte 1 más significativo.

““Little endianLittle endian”:”:Base address + 0 = Byte 0Base address + 0 = Byte 0Base address + 1 = Byte 1Base address + 1 = Byte 1

““Big endianBig endian”:”:Base address + 0 = Byte 1Base address + 0 = Byte 1Base address + 1 = Byte 0Base address + 1 = Byte 0

Acceso a los datosAcceso a los datos

Donde se Almacenan?Donde se Almacenan?RegistrosRegistrosMemoriaMemoriaStackStackEspacio de I/OEspacio de I/O

Como se acceden?Como se acceden?Modos de DireccionamientoModos de Direccionamiento

Movimiento de datos (Move, Load, Store,…)Movimiento de datos (Move, Load, Store,…) Aritméticas (Add, Sub, …)Aritméticas (Add, Sub, …) Lógicas (And, Xor, …)Lógicas (And, Xor, …) I/O. (In, Out)I/O. (In, Out) Transferencia de Control (Jump, Skip, Transferencia de Control (Jump, Skip,

Call…)Call…) EspecíficasEspecíficas

Ejemplo: Multimedia (MMX, SSE2, 3DNow!)Ejemplo: Multimedia (MMX, SSE2, 3DNow!)

OperacionesOperaciones

CodificaciónCodificación

Códigos de operación (Códigos de operación (OpCodeOpCode))Representa la operación …Representa la operación …

OperandoOperando/s Fuente/s FuenteA realizar sobre estos datos …A realizar sobre estos datos …

OperandoOperando Resultado ResultadoPone la respuesta aquí …Pone la respuesta aquí …

Referencia a la Referencia a la próxima instrucciónpróxima instrucciónCuando termina sigue por aquí …Cuando termina sigue por aquí …

Instrucción LOAD Instrucción LOAD Contenido del IR:Contenido del IR:

Opcode=1, Cargar en el AC el dato contenido en la Opcode=1, Cargar en el AC el dato contenido en la dirección 3.dirección 3.

Ejemplo: MarieEjemplo: Marie

Tipos típicos de arquitecturas:Tipos típicos de arquitecturas:

1. Orientada a Stack.1. Orientada a Stack.

2. Con acumulador.2. Con acumulador.

3. Con registros de propósito general.3. Con registros de propósito general. Los “tradeoffs”:Los “tradeoffs”:

Simpleza del hardware.Simpleza del hardware. Velocidad de ejecución.Velocidad de ejecución. Facilidad de uso.Facilidad de uso.

Características de ISAsCaracterísticas de ISAs

Arquitectura Stack: las instrucciones y operandos Arquitectura Stack: las instrucciones y operandos son tomados implícitamente del son tomados implícitamente del stackstack El El stackstack no puede ser accedido de forma aleatoria no puede ser accedido de forma aleatoria

(sino en un orden específico).(sino en un orden específico). Arquitectura acumulador: En cualquier operación Arquitectura acumulador: En cualquier operación

binariabinaria un operando esta implícito (el acumulador) un operando esta implícito (el acumulador) El otro operando suele ser la memoria, generando El otro operando suele ser la memoria, generando

cierto tráfico en el buscierto tráfico en el bus.. Arquitectura con registros de propósito general Arquitectura con registros de propósito general

(GPR): los registros pueden ser utilizados en lugar (GPR): los registros pueden ser utilizados en lugar de la memoriade la memoria Más rápido que la de acumulador.Más rápido que la de acumulador. Implementaciones eficientes usando compiladores.Implementaciones eficientes usando compiladores. Instrucciones más largas... (2 ó 3 operandos).Instrucciones más largas... (2 ó 3 operandos).

Características de ISAsCaracterísticas de ISAs

Instrucciones (Posibles)Instrucciones (Posibles)StackStack AcumuladorAcumulador RegistrosRegistros

MovimientoMovimiento PUSH XPUSH X

POP XPOP X

LOAD XLOAD X

STORE XSTORE X

Mov R1,R2Mov R1,R2

Load R1,XLoad R1,X

Store X,R1Store X,R1

AritméticasAritméticas AddAdd

SubSub

Add XAdd X

Sub XSub X

Add R1,R2,R3Add R1,R2,R3

Sub R1,R2,R3Sub R1,R2,R3

LógicasLógicas AndAnd

OrOr

NotNot

LELE

GEGE

EqEq

And XAnd X

Or XOr X

NotNot

And R1,R2,R3And R1,R2,R3

Or R1,R2,R3Or R1,R2,R3

Not R1, R2Not R1, R2

Cmp R1,R2Cmp R1,R2

ControlControl Jump XJump X

JumpT XJumpT X

JumpF XJumpF X

Call/Ret XCall/Ret X

Jump XJump X

Jump (AC)Jump (AC)

SkipCondSkipCond

Call X/RetCall X/Ret

Jump XJump X

Jump RJump R

Jump Cond RJump Cond R

Jump Cond XJump Cond X

Call X/R RetCall X/R Ret

Máquina de Acumulador:Máquina de Acumulador:• Representación binaria, complemento a 2.Representación binaria, complemento a 2.• Instrucciones de tamaño fijo.Instrucciones de tamaño fijo.• Memoria de 4K, accedida por palabras.Memoria de 4K, accedida por palabras.• Palabra de 16 bits.Palabra de 16 bits.• Instrucciones de 16 bits, 4 para el código de Instrucciones de 16 bits, 4 para el código de

operación y 12 para las direcciones.operación y 12 para las direcciones.• Una ALU de 16 bits.Una ALU de 16 bits.• 7 registros para control y movimiento de 7 registros para control y movimiento de

datos.datos.

MARIEMARIE

MARIEMARIE

MARIEMARIEOpCodeOpCode InstrucciónInstrucción

00000000 JnS XJnS X Almacena PC en X y Salta a X+1Almacena PC en X y Salta a X+1

00010001 Load XLoad X AC = [X]AC = [X]

00100010 Store XStore X [X]= AC[X]= AC

00110011 Add XAdd X AC = AC + [X]AC = AC + [X]

01000100 Subt XSubt X AC = AC - [X]AC = AC - [X]

01010101 Input Input AC = Entrada de PeriféricoAC = Entrada de Periférico

01100110 OutputOutput Enviar a un periférico contenido ACEnviar a un periférico contenido AC

01110111 HaltHalt Detiene la EjecuciónDetiene la Ejecución

10001000 SkipCond CondSkipCond Cond Salta una instrucción si se cumple la Salta una instrucción si se cumple la condición (00=>AC<0; 01=>AC=0; condición (00=>AC<0; 01=>AC=0; 10=>AC>0))10=>AC>0))

10011001 Jump DirJump Dir PC = DirPC = Dir

10101010 ClearClear AC = 0AC = 0

10111011 Addi XAddi X AC = AC + [ [ X ] ]AC = AC + [ [ X ] ]

11001100 Jumpi XJumpi X PC = [X]PC = [X]

Las Stack Machines Las Stack Machines no usanno usan operandos operandos en las instruccionesen las instrucciones

Salvo Salvo PUSH XPUSH X y y POP XPOP X que que requieren requieren una dirección de memoria como operandouna dirección de memoria como operando..

El resto obtienen los operandos del stack.El resto obtienen los operandos del stack.PUSHPUSH y y POPPOP operan sólo con el tope del operan sólo con el tope del

stack.stack. Operaciones binarias (ej. Operaciones binarias (ej. ADDADD, , MULTMULT) usan ) usan

los 2 primeros elementos del stack.los 2 primeros elementos del stack.

Stack MachinesStack Machines

Utilizan notación polaca inversaUtilizan notación polaca inversaJan Lukasiewicz (1878 - 1956).Jan Lukasiewicz (1878 - 1956).Notación infija: Z = X + Y.Notación infija: Z = X + Y.Notación postfija: Z = X Y +Notación postfija: Z = X Y +

No necesitan paréntesis!No necesitan paréntesis!infijainfija Z = (X Z = (X Y) + (W Y) + (W U), U),postfijapostfija Z = X Y Z = X Y W U W U + +

Stack MachinesStack Machines

Comparativa (Asignaciones)Comparativa (Asignaciones)

StackStack 1 Operando1 Operando RegistrosRegistros

2 Operandos2 Operandos

RegistrosRegistros

3 Operandos3 Operandos

PUSH XPUSH XPUSH YPUSH YMULTMULTPUSH WPUSH WPUSH UPUSH UMULTMULTADDADDPOP ZPOP Z

LOAD XLOAD XMULT YMULT YSTORE TEMPSTORE TEMPLOAD WLOAD WMULT UMULT UADD TEMPADD TEMPSTORE ZSTORE Z

LOAD R1,XLOAD R1,XMULT R1,YMULT R1,YLOAD R2,WLOAD R2,WMULT R2,UMULT R2,UADD R1,R2ADD R1,R2STORE Z,R1STORE Z,R1

MULT R1,X,YMULT R1,X,YMULT R2,W,UMULT R2,W,UADD Z,R1,R2ADD Z,R1,R2

Z = X Z = X Y + W Y + W U U

ControlControl

Nos permiten alterar la secuencia del Nos permiten alterar la secuencia del programaprogramaFundamental para implementar IF, While, etcFundamental para implementar IF, While, etcLlamadas a procedimientosLlamadas a procedimientos

Como decidimos la alteración de control?Como decidimos la alteración de control? IncondicionalIncondicionalCondicialCondicial

FlagsFlags

Registros que nos dan información de controlRegistros que nos dan información de control CarryCarry Overflow, UnderFlowOverflow, UnderFlow Zero, NegativeZero, Negative

Se modifican con operaciones aritméticas y Se modifican con operaciones aritméticas y lógicaslógicas

Se utilizan para realizar saltos condicionalesSe utilizan para realizar saltos condicionales JC, JNZ, JZ, etc.JC, JNZ, JZ, etc.

¿Por qué usar Flags y no preguntar por el valor ¿Por qué usar Flags y no preguntar por el valor de los registros o la memoria?de los registros o la memoria?

Comparativa (IF)Comparativa (IF)

Escribir este programa en diferentes Arquitecturas:

if X > 1 do

X := X + 1;

else

Y := Y + 1;

Solución MARIE (Acumulador)Solución MARIE (Acumulador)If, 100 Load X / AC=[X]

101 Subt One / AC=AC-1102 Skipcond 600/ Si AC<=0 (X<=1) Saltear103 Jump Else / Salto a ELSE104 Load X / AC=[X]

Then, 105 Add One / AC=AC+1106 Store X / X:= X + 1107 Jump Endif / Salta la parte ELSE

Else, 108 Load Y / Load Y109 Add One / Add 110A Store Y / Y:= Y + 1

Endif, 10B Halt / TerminarOne, 10C DEC 1 / One = 1X, 10D DEC ? / Espacio para XY, 10E DEC ? / Espacio para Y

Solución StackSolución StackIf, 100 Push X

101 Push 1102 LE / Si X<=1 pone un 1 el el stack103 JMPT Else / Si 1 va a else. Saca X y 1 del Stack

Then, 104 Push X105 Push 1106 Add107 Pop X / X:=X + 1108 Jump Endif / Salta la parte ELSE

Else, 109 Push Y 10A Push 110B Add10C Pop Y / Y:= Y + 1

Endif, 10D Halt / TerminarX, 10E DEC ? / Espacio para XY, 10F DEC ? / Espacio para Y

Solución Máquina PrácticaSolución Máquina PrácticaIf, 100 Mov R1, [X]

101 CMP R1,1102 JLE Else

Then, 105 Add R1,1 106 Mov [X],R1 / X:= X + 1107 Jump Endif / Salta la parte ELSE

Else, 108 Mov R1,[Y] 109 Add R1,110A Mov [Y],R1 / Y:= Y + 1

Endif, 10B Ret / Aquí terminaX, 10C DEC ? / Espacio para XY, 10D DEC ? / Espacio para Y

Comparativa (Ciclos)Comparativa (Ciclos)

Hacer este programa:Hacer este programa:int A[5]={10,15,20,25,30}int A[5]={10,15,20,25,30}Sum=0Sum=0i:=0i:=0While(i<5)While(i<5){{Sum=Sum+A[i];Sum=Sum+A[i];i++;i++;

}}

Ejemplo MarieEjemplo MarieStart, Load Num ; Cargo el Contador

SkipCond 800 ; Si AC<=0 Fin Jump EndLoad Sum ; AC=[Sum]Addi PostAct ; AC+=[[PostAct]]Store Sum ; [SUM]=ACLoad PostAct ; AC=[PostAct]Add Index ; Store PostAct ; [PosAct]=[PosAct]+IndexLoad Num ; AC=[Num]Sub OneStore Num ; [Num]=[Num]-1Jump Start

End, HaltVec, Dec 10 ; Num1 =10

Dec 15 ; Cada palabra del array es inicializadaDec 20Dec 25Dec 30

PostAct, Hex Vec ; Aquí hay que poner una direcciónNum, Dec 5 ; contador para el loop=5Sum, Dec 0 ; Suma=0Index, Dec 1One, Dec 1

Ejemplo Máquina PrácticaEjemplo Máquina PrácticaVec DW 10 ; Num1 =10

DW 15 ; Cada palabra del array es inicializadaDW 20DW 25DW 30

Num DW 5 ; contador para el loop=5Sum DW 0 ; Suma=0

MOV R2, Vec ; Apunta al VectorMOV R1, 0 ; AcumuladorMOV R3, R2 ; inicializa el offset (Dentro del array)MOV R4, [Num] ; R4 es el registro contador

Start: MOV R5, [R3] ; El dato del vector (R5 = [ [ Vec [i] ] ]ADD R1,R5ADD R3, 1 ; Avanza dentro del vectorSUB R4,1; Decrementa el contadorJNZ Start

End: Mov R5,SumMov [R5],R1 ; Grabo el resultado en Sum

Reutilización de códigoReutilización de códigoFunciones, Procedimientos, MétodosFunciones, Procedimientos, Métodos

SubrutinasSubrutinas

Programaprincipal

Subrutina

Llamado a Subrutina

Llamado a Subrutina

jj+1

SubrutinasSubrutinas

CALL subrutina CALL subrutina PC = subrutinaPC = subrutina

¿Pero como guardamos la ¿Pero como guardamos la dirección de retornodirección de retorno? ? (el viejo PC). ¿Y Los (el viejo PC). ¿Y Los argumentosargumentos?? En registrosEn registros

¿Y si los usamos?¿Y si los usamos?

En memoria. Por ejemplo al comienzo de la rutina…En memoria. Por ejemplo al comienzo de la rutina… ¿Qué pasa con la recursión?¿Qué pasa con la recursión?

¡Mejor usar un Stack!¡Mejor usar un Stack! Otro enfoque: Ventana de registrosOtro enfoque: Ventana de registros

SubrutinasSubrutinas

Código en llamador:Código en llamador:CALL subrutinaCALL subrutina

Esto implica (PUSH PC, PC = rutina)Esto implica (PUSH PC, PC = rutina)

Código en subrutinaCódigo en subrutinaRET RET

Esto implica (POP PC)Esto implica (POP PC)

Subrutinas EjemploSubrutinas Ejemplo Se desea hacer un programa que realice las siguientes

operaciones:

[0100] [0100] + 5[0200] [0200] + 5[0204] [0204] + 5

Programa principal SubrutinaMOV R1,0100 SUM5: MOV R2,[R1]CALL SUM5 ADD R2,5MOV R1,0200 MOV [R1],R2CALL SUM5 RETMOV R1,0204CALL SUM5

¿Que pasa si estábamos usando R2?

Subrutinas EjemploSubrutinas Ejemplo Se desea hacer un programa que realice las siguientes operaciones:

[0100] [0100] + 5[0200] [0200] + 5[0204] [0204] + 5

Programa principal SubrutinaMOV R1,0100 SUM5: PUSH R2CALL SUM5 MOV R2,[R1]MOV R1,0200 ADD R2,5CALL SUM5 MOV [R1],R2LOAD R1,0204 POP R2CALL SUM5 RET

En general, los registros que usan las rutinas deben ser salvados previamente en el Stack

Bloque de ActivaciónBloque de Activación

Argumentos

Dirección de Retorno

Registros Salvados

Variables Locales

FP

SP El puntero FP, a El puntero FP, a diferencia de SP, se diferencia de SP, se mantiene fijo durante mantiene fijo durante toda la ejecución del toda la ejecución del procedimiento, procedimiento, brindando un registro brindando un registro base estable para base estable para acceder a parámetros y acceder a parámetros y variables.variables.

•Contiene toda la información necesaria para la ejecución de la subrutina

•Generalmente armado por el compilador de un lenguaje de alto nivel

EjemploEjemplo

void P1(int n)void P1(int n){{

int i,j;int i,j;i = 5;i = 5;……

1111: P2(10,j);: P2(10,j);1212: j=i+1;: j=i+1; … …1515: return;: return;}}

void P2(int c,d)void P2(int c,d)

{{

int a,b;int a,b;

……

2121: return;: return;

}}

void main()void main(){{11:: P1(1)P1(1)22:return:return}}

j (local)j (local)

i (local)i (local)

Old FPOld FP

b (local)b (local)

a (local)a (local)

Old FPOld FP

Dir 12 (de P1)Dir 12 (de P1)

d=5 (arg)d=5 (arg)

c=10 (arg)c=10 (arg)

jj

II

Old FPOld FP

Dir 2 (de Main)Dir 2 (de Main)

n=1n=1

Cuando main llama a P1

FP

FP

SP

SP

Cuando P1 llama a P2

1. El procedimiento llamador se encarga de pushear los parámetros en el Stack

2. El call pushea el PC en el Stack

3. Antes de salir el procedimiento llamado se ocupa de limpiar del Stack las variables locales y el FP

4. El return asigna al PC la dirección que esta al tope del stack y la elimina

5. El llamador libera los parámetros

SPDir 2 (de Main)Dir 2 (de Main)

n=1 (arg)n=1 (arg)

Subrutinas (Ventana de registros)Subrutinas (Ventana de registros)

Evitar el uso del StackEvitar el uso del Stack Idea: tener muchos registros, pero permitir usar unos Idea: tener muchos registros, pero permitir usar unos

pocospocos Asignar registros a parámetros, argumentos y Asignar registros a parámetros, argumentos y

variables localesvariables locales Al hacer un Call “deslizarlos”Al hacer un Call “deslizarlos”

EnfoquesEnfoques

CISC (Complex Instruction Set Computer)CISC (Complex Instruction Set Computer) Instrucciones que realizan tareas complejasInstrucciones que realizan tareas complejas

RISC (Reduced Instruction Set Computer)RISC (Reduced Instruction Set Computer) Instrucciones que realizan operaciones Instrucciones que realizan operaciones

sencillassencillasMISC (Minimal Instruction Set Computer)MISC (Minimal Instruction Set Computer)

Mínimo de operaciones necesariasMínimo de operaciones necesariasOISC (One Instruction Set Computer)OISC (One Instruction Set Computer)

Una única instrucciónUna única instrucción

La mayoría de los sistemas actuales son La mayoría de los sistemas actuales son GPR GPR (general purpose registers).(general purpose registers).

3 tipos de sistemas:3 tipos de sistemas: Memoria-MemoriaMemoria-Memoria donde 2 o 3 operandos pueden donde 2 o 3 operandos pueden

estar en memoria.estar en memoria. Registro-MemoriaRegistro-Memoria donde al menos un operando es donde al menos un operando es

un registroun registro Load-StoreLoad-Store, donde las operaciones son sólo entre , donde las operaciones son sólo entre

registros.registros.

El número de operandos y de registros El número de operandos y de registros disponibles afectan directamente el tamaño de disponibles afectan directamente el tamaño de la instrucciónla instrucción

ISAsISAs

ReferenciasReferencias

Capítulo 5 – TanenbaumCapítulo 5 – TanenbaumCapitulo 4 y 5 – NullCapitulo 4 y 5 – NullCapitulo 10 – StallingsCapitulo 10 – Stallingshttp://www.cs.uiowa.edu/~jones/arch/risc/

Articulo sobre OISCArticulo sobre OISC