cap13profesores.elo.utfsm.cl/~tarredondo/info/comp-architecture/apuntes-lsb/cap13.pdfTitle: Microsoft Word - cap13.doc Created Date: 9/3/2004 9:48:48 AM

UNIVERSIDAD TECNICA FEDERICO SANTA MARIA DEPARTAMENTO DE ELECTRONICA

ELO311 Estructuras de Computadores

Prof. Leopoldo Silva Bijit. 03-09-2004 258

13. Diseño de un procesador multiciclo.

13.1 Reutilización de los recursos y tiempos de ejecución de acuerdo a la instrucción. En el modelo del procesador monociclo el período del reloj se ajusta con la ruta crítica combinacional, que es la establecida por la instrucción más lenta en completar sus transferencias. En el ejemplo que se desarrolla, la instrucción load word fija el período del reloj. Sin embargo debe tenerse en cuenta que el funcionamiento de la memoria se ha simplificado, ya que es posible que ésta no pueda efectuar sus funciones en un ciclo tan corto, como se verá más adelante; si lo que se desea leer no está en la memoria caché, debe buscarse en la caché secundaria, lo cual puede tomar dos a tres veces el tiempo que se emplea al operar con la caché primaria. Y si se produce un fallo de la secundaria, debe accesarse a la memoria principal, lo que tiene un costo de 20 a 50 ciclos. También si existen instrucciones que demoren demasiado tiempo (las de punto flotante, por ejemplo), la frecuencia del reloj debe ajustarse al tiempo de ejecución de la que más tarda en realizarse. Por otra parte los recursos pueden emplearse sólo una vez por cada ciclo de reloj, lo que lleva a duplicar algunas unidades funcionales (por ejemplo: sumadores, memoria). Estas razones conducen a pensar en permitir que las instrucciones puedan ser realizadas con varios ciclos de reloj; dependiendo de la complejidad de éstas, algunas podrán ser realizadas en pocos ciclos, otras necesitarán más ciclos. Es decir, aquéllas que terminan sus transferencias en menos tiempo, ocuparán menos ciclos de reloj (y se realizan en menos tiempo). Lo anterior permite que las instrucciones tengan tiempos de ejecución diferentes, ya que emplean diferente número de ciclos de reloj; y también permite realizar diseños de menor costo, al posibilitar el compartir los recursos y reutilizarlos durante la ejecución de una instrucción. Un recurso puede ser empleado más de una vez en la realización de una instrucción, siempre que se use en diferentes ciclos del reloj. En el modelo multiciclo que se describe, cada paso o etapa de ejecución debe emplear un ciclo de reloj.

13.2. Uso de registros para separar etapas. Los datos que serán empleados por las siguientes instrucciones deben ser almacenados en registros o en la memoria. Los datos que se emplearán en los siguientes ciclos del reloj, al ejecutar una determinada instrucción deben ser almacenados en registros adicionales. La ubicación de estos registros adicionales, dependerá de si el retardo de propagación de la unidad permite ajustarse al período del reloj, y por otra parte de que el dato sea ocupado en los próximos ciclos de ejecución de la misma instrucción.




También la necesidad de registros adicionales dependerá de si se desea compartir el recurso. Por ejemplo si se desea tener sólo una memoria, tanto para datos como para instrucciones, se requieren dos registros adicionales que capturen los datos leídos desde la memoria; uno para guardar la instrucción, otro para registrar la lectura de la memoria en la instrucción load word. Un esquema conceptual de la máquina monociclo, muestra una unidad combinacional con gran retardo de propagación, ubicada entre dos unidades de almacenamiento (memoria o registros): Si se pudiera dividir la unidad combinacional, en dos partes que supondremos con iguales tiempos de propagación, se tendrá el esquema siguiente: Se realiza el mismo trabajo, que en el esquema anterior, pero en dos ciclos más rápidos en lugar de uno más lento. Se agrega el tiempo de setup(ts) y de clock hasta la salida(tf), con respecto al caso anterior. Pero en un mismo ciclo de reloj, pueden ocuparse simultáneamente ambas etapas, esto es lo que permite compartir un recurso; ya que se lo puede usar en diferentes ciclos de ejecución de una misma instrucción. La ubicación de los registros que definen etapas o ciclos deben ser relativamente equilibrados, ya que esto tiende a minimizar la duración del ciclo del reloj.

T1 = tr + tp + ts + tskew > = Tclk1

Reg

Reg

Tclk1

T2 = T1/2

Etapa A Reg

Reg

Tclk2=Tclk1/2

T2 = T1/2

Etapa B

Reg

Adi

cion

alB




Ya vimos que en la especificación de las transferencias físicas del modelo monociclo, podían agruparse las transferencias según la unidad en que se realizaban. Si lo que se desea es que cada unidad opere en un ciclo de reloj, el análisis de las transferencias realizadas en cada unidad permite identificar los registros adicionales necesarios. Debe notarse que en el caso monociclo todas las transferencias, que están separadas en líneas, se están ejecutando con la información fluyendo a través de las etapas(y no hay registros intermedios) mediante la red de cables o buses(pero los cables no almacenan la información, salvo mientras dure la propagación a través de éstos). Se emplean los registros adicionales IR(registro de Instrucción), A y B(salidas de la Unidad de Registros), S(salida de Unidad de Operaciones) y M(Registro con el dato leído de la memoria. Memory Data Register). Estos registros se escriben en cada ciclo de reloj y no requieren control adicional, excepto IR que requiere mantener la información para la unidad de registros, la de ejecución y control. Sin embargo se han dibujado en el diagrama las señales de habilitación de escritura de registros adicionales, y también se incorporan las señales que los controlan en las secuencias correspondientes.

13.3. Etapas en la ejecución de instrucciones. Entonces se tienen cinco etapas para la ejecución de instrucciones(no todas las intrucciones emplean todas las etapas): 1. Búsqueda de la Instrucción. Lectura de Memoria de Instrucciones y cálculo de

dirección de próxima instrucción. 2. Decodificación de la Instrucción y lectura de registros. 3. Ejecución de operaciones con formato R y cálculo de la dirección efectiva de Memoria. 4. Lectura de Memoria de Datos o Escritura en Memoria de Datos. 5. Escritura en Registros. Pueden rescribirse las transferencias empleadas en el diseño del procesador monociclo, pero ahora cada línea representa un ciclo diferente de reloj. Por esta razón los grupos de micro operaciones que se realizan juntas en un ciclo de reloj, se separan por comas y el grupo está terminado en un punto y coma. El término de instrucción se marca con un punto. El período del reloj debe ajustarse a la duración de la etapa más lenta, de este modo en un ciclo de reloj pueden realizarse todas las acciones y transferencias de cada etapa. La activación de las señales que controlan las transferencias deben efectuarse asociadas a diferentes ciclos del reloj. Para lograr esto es preciso modelar la unidad de control como una máquina secuencial de estados finitos. En cada canto activo del reloj se pasa a un estado diferente (se captura el estado en los registros), y en cada estado pueden activarse las señales de control que se requieran (salidas de redes combinacionales alimentadas por los estados de los flip-flops de la unidad de control). Es decir las salidas de esta máquina secuencial deben estar asociadas al estado (modelo de Moore).




La ejecución de cada instrucción puede visualizarse como un recorrido en el diagrama de estados; algunas instrucciones se ejecutarán pasando por pocos estados, otras tendrán recorridos más largos. El número de estados por los que pasa una instrucción son los ciclos de reloj que demora en realizarse, y esto se mide en CPI(ciclos por instrucción). Podría ajustarse el período del reloj de acuerdo al tiempo de la etapa más rápida. Esto implica que el tiempo de las etapas será ahora un múltiplo de la etapa más rápida, lo cual aumenta el número de estados de la unidad de control, y complica su diseño. El siguiente diagrama muestra los registros que deben agregarse para ejecutar instrucciones con un número diferente de ciclos de reloj. Se muestran las señales de control en cada etapa. Se ha agregado el habilitamiento de escritura del registro de instrucción IR y de los registros adicionales A, B, S y M.

Unidad de Control

SUnidad

Registros

rs rt

busW

RegWr AluCtr

AluSrc RegDst

rd

ExtOp

Inm16

Addr

Memoria Datos

M

Din

MemRd

MemWr

0

1

MemtoReg

Unidad de

Operaciones

nPC_sel

Unidad de

Instrucción

COp+ Funct Equal

Reloj

WEPC

IR

A

B

WEIR WEA WEB WES WEM

2




Notar que la última etapa, la que escribe en los registros, hace fluir los datos hacia atrás. Por esta razón se denomina a esta etapa post escritura (write-back).

13.4. Transferencias físicas. A continuación se muestran las transferencias físicas para ejecutar las transferencias lógicas que definen cada una de las instrucciones del repertorio. Los grupos de micro operaciones que se realizan juntas en un ciclo de reloj, se separan por comas y el grupo está terminado en un punto y coma. El término de instrucción se marca con un punto. ADD: R[rd] ⇐ R[rs] + R[rt]; PC ⇐ PC + 4 IR = MemInst[PC], PC = PC+4; Unidad Instrucción. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = add(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. SUB: R[rd] ⇐ R[rs] – R[rt]; PC ⇐ PC + 4 IR = MemInst[PC], PC = PC+4; Unidad Instrucción. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = sub(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC ⇐ PC + 4 IR = MemInst[PC], PC = PC+4; Unidad Instrucción. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = slt(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. ORI: R[rt] ⇐ R[rs] + zero_ext(Inm16); PC ⇐ PC + 4 IR = MemInst[PC], PC=PC+4; Unidad Instrucción. A = R[rs]; Unidad Registros. Lectura. S = or(A , zero_ext(Inm16) ); Unidad Operaciones. R[rt] = S. Unidad Registros. Escritura. Las tres instrucciones anteriores no emplean la etapa de memoria. El ORI no requiere escribir en el registro B.




LOAD: R[rt] ⇐ MEM[ R[rs] + sign_ext(Inm16)]; PC ⇐ PC + 4 IR = MemInst[PC], PC=PC+4; Unidad Instrucción. A = R[rs]; Unidad Registros. Lectura. S = add( A , sign_ext(Inm16)); Unidad Operaciones. M = MemDat[S]; Unidad Memoria Datos. R[rt] = M. Unidad Registros. Escritura. STORE: MEM[ R[rs] + sign_ext(Inm16)] ⇐ R[rt]; PC ⇐ PC + 4 IR=MemInst[PC], PC=PC+4; Unidad Instrucción. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = add( A, sign_ext(Inm16)); Unidad Operaciones. MemDat[S] = B. Unidad Memoria Datos. La instrucción STORE no utiliza el arreglo de registros para escritura. Están permanentemente cableadas las conexiones del registro B en la entrada de datos Din de la memoria; y de la salida S de la ALU, en el bus Add de direcciones de la memoria de datos. BEQ: if ( R[rs] == R[rt] ) PC ⇐ (PC +4) + sign_ext(Inm16)*4 else PC ⇐ PC + 4 IR = MemInst[PC], PC=PC+4; Unidad Instrucción. A = R[rs], B = R[rt]; Unidad Registros. Lectura. if (Equal) Unidad Operaciones. PC = PC + sign_ext(Inm16)*4. Unidad Instrucción. BEQ no ocupa las etapas de Memoria de Datos ni escritura en arreglo de Registros. Notar que en el primer ciclo se escribe en PC, la dirección de la próxima instrucción. En el tercer ciclo, puede emplearse dicho valor para calcular la dirección de bifurcación relativa a PC, lo cual permite compartir el sumador de la unidad de instrucción. Esto implica un cambio de la unidad de instrucción, que se muestra más adelante. J UMP: PC ⇐ (PC +4)&0xF0000000+ add_26 *4 IR = MemInst[PC], PC=PC+4; Unidad Instrucción. PC = (PC)&0xF0000000 + add_26 *4. Unidad Instrucción. Se muestra la unidad de Instrucción modificada, se agrega un mux y se comparte el sumador, empleándolo dos veces en la realización de las instrucciones beq y jump(pero en ciclos diferentes de reloj): La necesidad del registro IR, se debe a que durante el primer ciclo se calcula la dirección de la próxima instrucción y se lo escribe en el registro PC. Al cambiar éste, cambia el bus de




direcciones de la memoria de instrucciones, esto requiere almacenar la instrucción para tener los campos disponibles en el resto de la ejecución. En caso de no escribir en PC hasta el término de la ejecución de la instrucción, se debe mantener la estructura de la unidad de instrucciones (que requiere dos sumadores) del procesador monociclo, y mantener las señales de control de la memoria de instrucciones en los siguientes ciclos que requieran leer campos de la instrucción. De esta forma podría no emplearse el registro IR. Si se comparte la memoria para datos e instrucciones, el registro IR es indispensable, ya que las instrucciones load word y store word, cambian el bus de direcciones de la memoria. Si no se cambian los contenidos de rd, rs, y rt, no se requieren los registros A y B. Además esto implica sostener los controles RegDst y RegWr en los ciclos en que se requiera mantener estables los contenidos del busA y busB. Sin embargo si A y B están presentes, se simplifica el diseño de la unidad de control; sólo es necesario activar los habilitamientos de escritura de A y B en el segundo ciclo. No es necesario activarlos en los ciclos que siguen, pues ya están registrados los contenidos de los buses A y B en dichos registros. Similar razonamiento puede emplearse para detectar la necesidad del registro S. Si la unidad de operaciones no se utiliza con diferentes operandos en diferentes ciclos de la

PC

SigExt*4

4

AddrMemoriaInstruc-ciones

Rd

"1"

Inm16

WEPC

Funct COp

Rs Rt Rd

Inm16

PC[31..28]

0..1

add_26

0

1 IR

WEIR

0

1




ejecución de una misma instrucción(es decir si no se la comparte) no se requiere el registro S; pero esto implica sostener las señales de control a esta unidad en ciclos subsecuentes que requieran una salida estable de AluOut.

13.5. Señales de control. Se describen a continuación, las señales de control que activan las transferencias físicas. El primer ciclo es común a todas las instrucciones. En él se lee la instrucción que se ejecutará y se la almacena en IR, en PC se guarda la dirección de la próxima instrucción. A este ciclo se lo denomina de búsqueda de instrucción (fetch). Después de este ciclo, los campos de la instrucción quedan disponibles en las salidas de IR. ADD: R[rd] ⇐ R[rs] + R[rt]; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA , WEB ; Unidad Registros. Lectura. AluSrc = "busB", AluCtr = “add”; WES ; Unidad Operaciones. RegDst = "rd" , Memtoreg="alu", RegWr. Unidad Registros. Escritura. En el segundo ciclo de ADD y SUB, se guardan en A y B los operandos de la instrucción, una vez que han sido leídos del arreglo de registros. Durante el ciclo se activan las habilitaciones de escritura, y sólo en el canto sincronizante del reloj se registran los valores. En el tercer ciclo de ADD y SUB, se almacena en S, el resultado de la operación. En el cuarto ciclo de ADD y SUB se escribe en el registro destino el resultado de la operación que fue salvado en el registro S, en el ciclo anterior. Ambas operaciones requieren cuatro ciclos de reloj para completarse. SUB: R[rd] ⇐ R[rs] – R[rt]; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA , WEB ; Unidad Registros. Lectura. AluSrc = "busB", AluCtr = “sub”, WES ; Unidad Operaciones. RegDst = "rd", Memtoreg="alu", RegWr. Unidad Registros. Escritura. SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA , WEB ; Unidad Registros. Lectura. AluSrc = "busB", AluCtr = “slt”, WES ; Unidad Operaciones. RegDst = "rd", Memtoreg="alu", RegWr. Unidad Registros. Escritura.




ORI: R[rt] ⇐ R[rs] + zero_ext(Inm16); PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA ; Unidad Registros. Lectura. AluSrc = "Op32", ExtOp = “zero”, AluCtr = “ori”, WES ; Unidad Operaciones. RegDst = "rt", Memtoreg="alu", RegWr. Unidad Registros. Escritura. En el segundo ciclo de ORI se escribe en A el contenido del operando especificado en el registro Rs. En el tercer ciclo de ORI se escribe en S, el resultado del or del operando en registro con el operando inmediato, extendido sin signo. En el cuarto ciclo de ORI se escribe en el registro destino(rt) el valor guardado en S, en el ciclo anterior. La operación ORI requiere cuatro ciclos para completar sus transferencias físicas. LOAD: R[rt] ⇐ MEM[ R[rs] + sign_ext(Inm16)]; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA ; Unidad Registros. Lectura. AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WES ; Unidad Operaciones. MemRd, WEM ; Unidad Memoria Datos. RegDst = "rt", Memtoreg = "mem", RegWr. Unidad Registros. Escritura. En el segundo ciclo de LOAD se escribe en A el contenido del operando especificado en el registro base Rs. En el tercer ciclo de LOAD se escribe en S la dirección efectiva de la celda de la memoria que se leerá, que es el resultado de la suma del operando en registro base con el desplazamiento inmediato, extendido con signo. En el cuarto ciclo de LOAD se lee la memoria de datos y se registra la lectura en M. En el quinto ciclo de LOAD se escribe en el registro destino(rt) el valor guardado en M, en el ciclo anterior. La operación LOAD requiere cinco ciclos para completar sus transferencias físicas. STORE: MEM[ R[rs] + sign_ext(Inm16)] ⇐ R[rt]; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA , WEB ; Unidad Registros. Lectura. AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WES ; Unidad Operaciones. MemWr. Unidad Memoria Datos.




En el segundo ciclo de STORE se escribe en A el contenido del operando especificado en el registro base Rs. Y en B se almacena el contenido del registro rt, que será escrito en la memoria. En el tercer ciclo de STORE se escribe en S la dirección efectiva de la celda de la memoria que se escribirá, que es el resultado de la suma del operando en registro base con el desplazamiento inmediato, extendido con signo. En el cuarto ciclo de STORE se escribe en la memoria de datos en la dirección establecida por S(en el ciclo anterior) el valor que ya se tiene en B, desde dos ciclos antes. La operación STORE requiere cuatro ciclos para completar sus transferencias físicas. BEQ: if ( R[rs] == R[rt] ) PC ⇐ (PC +4)+ sign_ext(Inm16)*4 else PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. WEA , WEB ; Unidad Registros. Lectura. if (Equal) { nPC_sel = “Br” , WEPC }. Unidad Instrucción. En el segundo ciclo de BEQ se leen los registros y se determina el valor de la señal Equal. En el tercer ciclo de BEQ, si debe realizarse la bifurcación, se sobreescribe PC; en caso contrario, no se cambia el valor de PC ya escrito en el primer ciclo. La instrucción BEQ tiene un CPI igual a tres. Utiliza la unidad de instrucción dos veces en la ejecución. J: PC ⇐ (PC +4)&0xF0000000+ add_26 *4 nPC_sel = “+4”, WEPC , WEIR ; Unidad Instrucción. nPC_sel = “Jmp”, WEPC . Unidad Instrucción. En el segundo ciclo del salto incondicional, se sobreescribe PC con la dirección de salto. Se ocupa dos veces, en ciclos diferentes de reloj, la unidad de instrucción. Y tiene CPI = 2.

13.6. Comportamiento del procesador multiciclo. Si definimos, en general: TE = Tiempo de ejecución de un programa de prueba. C = Comportamiento Procesador = 1/ TE (a mayor tiempo, peor comportamiento) NI = Número de instrucciones del programa de prueba. CPI = Ciclos de reloj por instrucción. (será diferente de uno en caso multiciclo) PC = Período del reloj. Se tiene que: TE = NI * CPI * PC




Para el procesador monociclo con un período fijo de reloj, se tiene: TE(monociclo) = NI*1*PCmono Se asume que el programa de prueba está constituido por la siguiente mezcla: 25% de cargas, 11% de almacenamientos, 30% de sumas, 9% de restas, 4% de or inmediatos, 15% de bifurcaciones y 6% de saltos. Se tendrá ahora: TE(multiciclo) = NI (0,25*5+0,11*4+0,30*4+0,09*4+0,04*4+0,15*3+0,06*2)*PCmulticiclo =NI*3,98*PCmulticiclo Puede considerarse que el valor promedio de CPI para la mezcla es de 3,98. Si la subdivisión en etapas, se realiza de tal modo que éstas requieran igual tiempo, podría modelarse cualitativamente que el período del reloj, en el caso monociclo, es cinco veces mayor que el requerido por el procesador multiciclo. La elección de tiempos iguales para las etapas tiende a minimizar el período del reloj requerido. La comparación: C(multiciclo)/ C(monociclo) = TE(monociclo) /TE(multiciclo) = PCmono/ (3,98*PCmulticiclo) = 5/3,98 = 1,26. indica que el procesador multiciclo es 1,26 veces más rápido que el monociclo. No apreciándose ventajas significativas en el aumento de velocidad, mayormente debido a que el repertorio elegido no contiene instrucciones complejas. La comparación anterior no refleja bien las bondades del diseño multiciclo; en el caso del diseño del repertorio completo existen alrededor de 100 instrucciones y algunas de ellas demandan hasta 20 ciclos de reloj. En este caso el numerador aumentaría a 20(monociclo) y el CPI promedio(multiciclo) no subiría apreciablemente si las instrucciones largas son poco frecuentes.

13.7. Alcances de compartir recursos.

13.7.1. Compartir memoria. En la elección realizada para el camino de datos no se comparten demasiados recursos, que es otra poderosa ventaja del esquema de diseño multiciclo. Puede tenerse sólo una unidad aritmética y compartirla para las operaciones de las unidades de instrucción y operación, también puede compartirse la memoria de instrucciones y de datos; también puede obtenerse la condición de igualdad utilizando la misma unidad aritmética. Este desarrollo es




el que efectúa el texto guía, en él puede verse que se ahorran recursos sin disminuir la velocidad de ejecución. A continuación se muestra una arquitectura que comparte la memoria de datos con la de instrucciones. Para esto es necesario modificar la unidad de instrucción, sacando de ésta la memoria de instrucciones.

PC

SigExt*

+4

Inm16

WEPC

PC[31..28]

0..1

add_26

01

0

1

Unidad de Control

SUnidad

Registros

rsrt

RegWr AluCtr

AluSrc RegDst

rd

ExtOp

Inm16

Din

MemRdMemWr

10

MemtoReg

Unidad de

Operaciones

nPC_sel

Unidad de

Instrucción

Cop Funct

Equal

Reloj

WEPC

IR

A

B

Addr

Memoria

M

WEIR

1 0

MemCtr

IR

WEM




Se ha agregado un mux controlado por MemCtr, que permite leer la dirección apuntada por PC, que contiene la instrucción actual, y grabarla en IR; o bien leer la dirección efectiva de la memoria apuntada por S, y grabar el dato en M. El compartir el recurso, no cambia la velocidad de ejecución de las instrucciones. Se ha sacado de la Unidad de Instrucción la memoria de programa, y se muestra que a esta unidad ingresa el bus IR. Se ilustra la descripción de las transferencias físicas con la instrucción load word: LOAD: R[rt] ⇐ MEM[ R[rs] + sign_ext(Inm16)]; PC ⇐ PC + 4 IR = M[PC], PC=PC+4; Unidad Instrucción. A = R[rs]; Unidad Registros. Lectura. S = add( A , signext(Inm16)); Unidad Operaciones. M = M[S]; Unidad Memoria Datos. R[rt] = M. Unidad Registros. Escritura. Las secuencias de control para la instrucción store word: STORE: MEM[ R[rs] + sign_ext(Inm16)] ⇐ R[rt]; PC ⇐ PC + 4 nPC_sel = “+4”, WEPC , WEIR , MenCtr=”Instrucciones”; Unidad Instrucción. WEA ; WEB ; Unidad Registros. Lectura. AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”, WES ; Unidad Operaciones. MemWr, MenCtr=”Datos” Unidad Memoria Datos. 13.7.2. Compartiendo la ALU. A continuación se muestra una arquitectura que además de compartir la memoria comparte la unidad aritmética. Para esto es necesario modificar la unidad de instrucción, sacando de ésta el sumador.

nPC sel WEPC

PC

PC[31..28]

add_26

0

2

AluOut

1 S

jump




Nótese que se han simplificado los recursos que emplea la unidad de instrucción. Sólo queda el circuito que forma la dirección de salto: jump = PC &0xF0000000 + add_26 *4 La formación de la dirección de salto requiere que el valor que debe estar estar almacenado en PC, sea la dirección siguiente a la instrucción que está en ejecución(la que está almacenada en IR). El multiplexor controlado por nPC_sel puede ser alimentado por la salida de la ALU(para formar PC+4, como se verá luego) y desde el registro S(para formar la dirección de salto en caso de bifurcación). Para compartir la ALU, se requiere modificar la Unidad de Operaciones. Permitiendo ingresar la salida del registro PC o el busA en el primer operando. También deben agregarse las entradas +4 y la dirección de bifurcación, como posibles segundos operandos. También se comparte la unidad extensora. Tomando el operando de 32 bits(Op32) y generando, por reordenamiento de las señales del bus, la nueva señal: branch = sign_ext(Inm16)*4 Con estas modificaciones, las transferencias físicas, pueden expresarse, según: ADD: R[rd] ⇐ R[rs] + R[rt]; PC ⇐ PC + 4

Inm16

AluOut

Op32

Extensor

AluCtr

AluSrcB

Igual

Equal

busA

busB

ExtOp

0

3

1

2branch

+ 4

1

0

PC

AluSrcA




IR = M[PC], PC = add(PC,+4); Unidad Instrucción, Operaciones. A=R[rs], B=R[rt]; Unidad Registros, Lectura. S = add(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. SUB: R[rd] ⇐ R[rs] – R[rt]; PC ⇐ PC + 4 IR = M[PC], PC = add(PC,+4); Unidad Instrucción y Operaciones. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = sub(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC ⇐ PC + 4 IR = M[PC], PC = add(PC, +4); Unidad Instrucción y Operaciones. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = slt(A, B); Unidad Operaciones. R[rd] = S. Unidad Registros. Escritura. ORI: R[rt] ⇐ R[rs] + zero_ext(Inm16); PC ⇐ PC + 4 IR = M[PC], PC = add(PC, +4); Unidad Instrucción y Operaciones. A = R[rs]; Unidad Registros. Lectura. S = or(A , zero_ext(Inm16) ); Unidad Operaciones. R[rt] = S. Unidad Registros. Escritura. LOAD: R[rt] ⇐ MEM[ R[rs] + sign_ext(Inm16)]; PC ⇐ PC + 4 IR = M[PC], S = add(PC, +4); Unidad Instrucción y Operaciones. A = R[rs]; Unidad Registros. Lectura. S = add( A , sign_ext(Inm16)); Unidad Operaciones. M = M[S]; Unidad Memoria Datos. R[rt] = M. Unidad Registros. Escritura. STORE: MEM[ R[rs] + sign_ext(Inm16)] ⇐ R[rt]; PC ⇐ PC + 4 IR=M[PC], PC = add(PC, +4); Unidad Instrucción y Operaciones. A=R[rs], B=R[rt]; Unidad Registros. Lectura. S = add( A, sign_ext(Inm16)); Unidad Operaciones. M[S] = B. Unidad Memoria Datos. BEQ: if ( R[rs] == R[rt] ) PC ⇐ (PC +4) + sign_ext(Inm16)*4 else PC ⇐ PC + 4




IR = M[PC], PC = add(PC, +4); Unidad Instrucción y Operaciones. A = R[rs], B = R[rt]; Unidad Registros. Lectura. S = add( PC, sign_ext(Inm16)*4); Unidad Operaciones. if (Equal) PC = S. Unidad Operaciones. Unidad Instrucción. J UMP: PC ⇐ (PC +4)&0xF0000000+ add_26 *4 IR = M[PC], PC = add(PC, +4); Unidad Instrucción y Operaciones. PC = (PC)&0xF0000000 + add_26 *4. Unidad Instrucción. Las señales de control, pueden describirse por: ADD: R[rd] ⇐ R[rs] + R[rt]; PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA , WEB ; AluSrcA = "busA", AluSrcB = "busB", AluCtr = “add”; WES ; RegDst = "rd" , Memtoreg="alu", RegWr. SUB: R[rd] ⇐ R[rs] – R[rt]; PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA , WEB ; AluSrcA = "busA", AluSrcB = "busB", AluCtr = “sub”; WES ; RegDst = "rd" , Memtoreg="alu", RegWr. SLT: if( R[rs] < R[rt]) R[rd] = 1; else R[rd] =0; PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA , WEB ; AluSrcA = "busA", AluSrcB = "busB", AluCtr = “slt”; WES ; RegDst = "rd" , Memtoreg="alu", RegWr. ORI: R[rt] ⇐ R[rs] + zero_ext(Inm16); PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA ; AluSrcA = "busA", AluSrcB = "Op32", ExtOp = “zero”, AluCtr = “ori”, WES ; RegDst = "rt", Memtoreg="alu", RegWr.




LOAD: R[rt] ⇐ MEM[ R[rs] + sign_ext(Inm16)]; PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA ; AluSrcA = "busA", AluSrcB = "Op32", ExtOp = “sign”, AluCtr = “add”, WES ; MemRd, WEM ; RegDst = "rt", Memtoreg = "mem", RegWr. STORE: MEM[ R[rs] + sign_ext(Inm16)] ⇐ R[rt]; PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA , WEB; AluSrcA = "busA", AluSrcB = "Op32", ExtOp = “sign”, AluCtr = “add”, WES ; MemWr. BEQ: if ( R[rs] == R[rt] ) PC ⇐ (PC +4)+ sign_ext(Inm16)*4 else PC ⇐ PC + 4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; WEA , WEB ; AluSrcA = "PC", AluSrcB = "branch", AluCtr = “add”, WES ; if (Equal) { nPC_sel = “S” , WEPC }. J: PC ⇐ (PC +4)&0xF0000000+ add_26 *4 nPC_sel = “alu”, AluSrcA = "PC", AluSrcB = "+4", AluCtr = “add”, WEPC , WEIR; nPC_sel = “Jmp”, WEPC .

13.8. Diseño de la unidad de control del procesador multiciclo. Puede confeccionarse un diagrama de estados a partir de las señales de control de cada etapa. Debido a que la primera serie de microoperaciones, para la etapa de búsqueda de instrucción, es igual para todas las instrucciones, se considera como el estado inicial. Luego a partir de éste se colocan las secuencias de estados para generar las señales de control para cada etapa. En el interior de cada estado se colocan las salidas asociadas a ese estado. Después de la última microoperación de cada secuencia(cuando se encuentra un punto en la secuencia), debe volverse al estado inicial, para seguir ejecutando instrucciones. Después de realizadas las transferencias del estado fetch(o de búsqueda de la instrucción), se disponen de las entradas para la unidad de control: el código de operación y el campo funct. De acuerdo al valor de las entradas se cambia al estado siguiente, cuando ocurre el canto del reloj. Cuando no están rotuladas las transiciones se asume que el próximo canto activo del reloj cambia al próximo estado de la secuencia.




Pueden aplicarse las técnicas tradicionales del diseño de máquinas secuenciales. Puede emplearse métodos para la reducción de estados. Por ejemplo: el tercer estado de lw y sw son idénticos, y podrían fundirse en uno; en este caso las dos salidas de este estado deben estar rotuladas con el código de operación de lw y sw(esto debido a que el cuarto estado de éstas no es el mismo). También pueden fundirse los cuartos estados de add y sub. Si se decide escribir en el registro B, en el caso de ori y lw(no importa lo que se escriba, si luego no se lo usa), se tendrá que el segundo estado de todas las instrucciones excepto el jump pueden fundirse; en caso de efectuar esta reducción, las salidas de este segundo estado común debe estar rotuladas con los códigos de operación de las instrucciones. Luego se procede a asignar estados y continuar con las metodologías de diseño.

13.8.1. Diagrama de estados El modelo del diagrama de estados debe entenderse como un modelo conceptual del problema del control. En el caso de diseñar un repertorio completo, no es práctico ocuparlo para describir cientos de estados con posibles centenares de secuencias diferentes(más aún si el tipo de repertorio es complejo y posee diversos modos de direccionamiento). Se verá más adelante la técnica de microprogramación, que básicamente consiste en diseñar la unidad de control como si fuera un computador en miniatura. El siguiente diagrama de estado muestra las diferentes secuencias de las señales de control para cada una de las instrucciones del repertorio:




13.8.2. Control de Memorias Asincrónicas. En el diagrama de estados puede fácilmente incorporarse controles asincrónicos mediante ciclos de espera(wait).

nPC_sel = “+4”, WEPC , WEIR ;

WEA

WEB WEA

WEB WEA

WEA

WEA

WEB WEA

WEB nPC_sel = Jmp WEPC.

RegDst =rd Memto reg=alu RegWr.

RegDst =rd Memto reg=alu RegWr.

RegDst =rt Memto reg=alu RegWr.

MemRd WEM

MemWr.

nPC_sel = if (Equal) { Br , WEPC

}.

AluSrc =busB, AluCtr = add WES

AluSrc =busB, AluCtr = sub WES

AluSrc =Op32 ExtOp =zero AluCtr = ori WES

AluSrc = Op32 ExtOp =sign AluCtr = add WES

AluSrc = Op32 ExtOp =sign AluCtr = add WES

RegDst =rt Memto reg=mem RegWr.

Add Sub Ori Lw Sw Beq J




Algunas memorias después de transcurrido el tiempo de acceso activan una señal indicando este evento. El controlador puede adaptarse a memorias con diferente tiempo de acceso empleando la señal(asincrónica) de wait proveniente de la memoria. Consideremos, por ejemplo, la memoria de instrucciones con los controles MemRd para leer y Wait. Mientras esta última está alta debe esperarse, ya que aún no termina el tiempo de acceso; cuando Wait se desactiva, el dato en el bus es válido. El siguiente esquema ilustra una parte de la Unidad de Instrucciones: El siguiente diagrama de estados incorpora ciclos de espera, empleando la señal wait: Se espera un múltiplo del período del reloj(se dice que es asincrónico, pero el tiempo que permanece esperando es sincrónico con el reloj; es la señal la que se produce en forma asincrónica al reloj).

MemRD WEIR&Wait' WEPC&Wait'

WEA .. ..

Wait

Wait’

AddrMemoria

Instrucciones

Rd

MemRd

PC

WEPC WEIR

IR

Wait




Nótese que las señales que habilitan la escritura de los registros PC e IR se activan cuando la memoria de instrucciones tiene datos válidos(cuando Wait pasa a cero). Lo anterior impide cambiar el valor de PC(es decir el bus de direcciones de la memoria) cuando aún se está leyendo; y de reactualizar con datos inválidos el registro de instrucción. La lógica combinacional que genera las señales de control de sincronización queda mejor descrita por: if (Wait) {WEIR = 0; WEPC = 0;} else {WEIR = 1; WEPC = 1;} Similar procedimiento se emplea, en la memoria de datos, en el ciclo de lectura de lw; y en el de escritura de sw.

13.9 Excepciones. (Interrupciones y Traps) El flujo de control normal, es la ejecución secuencial de instrucciones, de saltos, bifurcaciones, llamados a subrutinas y retornos. Una excepción es una transferencia de control de ejecución no programada. Es una señal que avisa que ha ocurrido un evento que requiere ser atendido. El sistema debe estar programado para tomar una acción para manipular la excepción: • registrandro la dirección de la instrucción que causó la excepción, • salvando el estado del procesador, • tomando una acción correctiva, • recuperando el estado del procesador y • devolviendo el control al programa que causó la excepción. La manipulación de excepciones ocasiona un control complejo, lo cual disminuye la velocidad de procesamiento, ya que tiende a aumentar el CPI promedio. MIPS define que no debe ejecutarse la instrucción que causa la excepción.

Programa de Usuario. Se produce excepción...

Manipulador de

Excepciones. (trap handler) Servicio de excepción.




13.9.1. Tipos de Excepciones: Interrupciones: • Causadas por eventos externos.

Solicitación de dispositivo de entrada/salida • Asincrónicas con la ejecución del programa.

Deben ser manipuladas entre instrucciones. Suspenden y reanudan la ejecución del programa.

Traps: • Causadas por eventos internos.

♦ Condiciones de excepción (ej. overflow) ♦ Errores (ej. paridad) ♦ Fallas (ej. De página) ♦ Llamados al Sistema ♦ Intento de ejecutar instrucción ilegal.

• Sincrónicas con la ejecución del programa • Las condiciones deben ser remediadas por el manipulador. • La instrucción puede ser reintentada o simulada y el programa continúa o éste debe ser

abortado.

13.9.2. Formas de accesar al manipulador de excepciones: Los diferentes procesadores emplean mecanismos especiales para manipular la excepción. En el caso del procesador MIPS, cuando se produce una excepción se pasa a modo kernel, cambiando el valor de PC a una dirección fija. Entrada fija. PC = 0x80000080 (MIPS) Otros procesadores emplean vectores o tablas de direcciones: Tabla de direcciones. PC = M[base+causa] (8051) Vectores de Interrupción. PC = base+causa

13.9.3. Formas de salvar el Estado. • En el stack. • En registros especiales. EPC, BadVaddr, Status, Cause (MIPS) • Cambios de banco o registros sombreados. En el caso del procesador MIPS se agregaron los siguientes recursos al camino de datos para manipular excepciones:




Registro EPC. Registro 14 del coprocesador 0, es un registro de 32 bits que almacena la dirección de la instrucción que ocasiona la excepción. Debe ser capaz de deshacer la suma PC = PC+4, ya que EPC debe apuntar a la instrucción que causa la excepción y no a la siguiente. Es decir: EPC = PC-4. Registro Cause. Registro 13 del procesador 0, de 32 bits. Almacena la causa de la excepción. Registro BadVAddr. Registro 8 del coprocesador 0, contiene la dirección de la instrucción que efectuó un direccionamiento ilegal. Registro Status. Registro 12 del coprocesador 0, contiene las máscaras de interrupción y los bits de habilitación. Es preciso modificar el camino de datos, además de agregar registros: Se agrega una entrada al mux controlado por nPC_Sel, con la dirección fija del manipulador de excepciones: 0x8000 0080 Señales de control para escribir en los registros: EPC, Cause, BadVAddr, y Status.

13.9.4 Modos: User y Kernel. Proporcionar dos modos de ejecución facilita el desarrollo del sistema operativo, que es un programa especial que corre en modo privilegiado (modo kernel o system) que le permite tener acceso a todos los recursos del computador. Normalmente todos los procesos de entrada/salida son administrados por el sistema operativo. De este modo cada programa de usuario puede compartir recursos (archivos, discos, memoria, pantalla, red, etc.) en forma organizada. El manipulador de excepciones es parte del sistema operativo, en éste se programan las acciones en respuesta a eventos que ocurran mientras se ejecuta el programa del usuario. Se describen a continuación algunos registros del coprocesador 0. Estos están implementados en el simulador Spim, y descritos en el manual.

13.9.5. Registro de Estado. (STATUS) Se tienen ocho niveles de interrupción, cinco son de hardware y tres de software. Existe un bit por nivel que habilita(cuando es uno) o deshabilita el nivel de interrupción. Máscaras k e k e k e 31 16 15 8 7 6 old previo actual Los 6 bits menos significativos forma un stack de tres niveles.




Los seis bits menos significativos indican si la interrupción se produjo en modo kernel o en modo usuario, para esto se emplea el bit denominado k, en el esquema anterior. Un uno indica que se produjo en modo kernel; cero en modo usuario. En los bits denominados e se registra si están habilitadas las interrupciones, con un uno se marca que estaban habilitadas y con un cero deshabilitadas. Cuando se produce una interrupción, los seis bits menos significativos se desplazan en dos posiciones hacia la izquierda, dejando en cero las últimas dos posiciones. Esto implica que se corre en modo kernel con las interrupciones deshabilitadas.

13.9.6. Registro CAUSE. Pendientes Causa 31 16 15 10 9 6 5 2 Los bits 10 al 15, se emplean para registrar si existen interrupciones pendientes de uno de los cinco niveles de interrupciones de hardware. Se setea a uno si ocurre la interrupción, y si ésta aún no ha sido servida. Se emplea para manejar la situación en que se hayan generado. Del bit 2 al 5 se registra la razón de la interrupción: 0 (Int) indica una interrupción externa. 4 (ADDRL) excepción por error de dirección no alineada en el fetch o en instrucción load 5 (ADDRS) excepción por error de dirección no alineada en instrucción store. 6 (IBUS) error de dirección en fetch de instrucción. 7 (DBUS) error de bus en búsqueda de datos. 8 (Syscall) excepción por llamado errado al sistema. 9 (BKPT) excepción por breakpoint. 10 (RI) excepción por instrucción reservada. 12 (OVF) Excepción por rebalse aritmético. 13 Resultado punto flotante inexacto. 14 Resultado punto flotante inválido. 15 División por cero. 16 Rebalse punto flotante. 17 Vaciamiento punto flotante.

13.9.7. Instrucciones para el Coprocesador 0. Existen instrucciones y macros que permiten mover datos del coprocesador 0 hacia el principal y viceversa. • Data transfer: lwc0, swc0 • Move: mfc0, mtc0 Ver trap.handler de spim(se lo incluye más adelante).




13.9.8. Tratamiento de excepciones en la máquina de estados. Se ilustran las modificaciones al diagrama de estados para tratar excepciones de dos tipos: rebalse e instrucción ilegal. Una instrucción indefinida o ilegal se detecta cuando no está definido el próximo estado para el código ilegal. Se define un próximo estado, al que se pasa cuando el código de operación es otro (diferente de lw, sw, j, beq, ori, tipo-R), en el cual se activan las microoperaciones para generar la excepción. La dirección ExcAdd es la del manipulador de excepciones. Rebalse aritmético. Se emplea la condición generada por la ALU, para saltar a un estado que genera excepción. Manipular las diferentes interacciones entre instrucciones y otros eventos que causan excepciones puede dar origen a un control complejo. El objetivo es mantener simple y rápida la lógica de control. Es tratamiento de las excepciones es el aspecto más complejo del control.

13.9.9. Código del manipulador de Excepciones de SPIM. # SPIM S20 MIPS simulator. # The default trap handler for spim. # Copyright (C) 1990-1995 James Larus, [email protected]. # Define the exception handling code. This must go first!

E0 (fetch)

E1 E2 E3 E4 E5 E6 E7

E14 E15

E16

E17 E18

E13 E8

oper. E9

oper. E10 E11 E12

E19

Add Sub Ori Lw Sw Beq J

EPC=PC-4 PC=ExcAdd Cause=10(RI)

otro

EPC=PC-4 PC=ExcAdd Cause=12(Ovf)

overflow




.kdata __m1_: .asciiz " Exception " __m2_: .asciiz " occurred and ignored\n" __e0_: .asciiz " [Interrupt] " __e1_: .asciiz "" __e2_: .asciiz "" __e3_: .asciiz "" __e4_: .asciiz " [Unaligned address in inst/data fetch] " __e5_: .asciiz " [Unaligned address in store] " __e6_: .asciiz " [Bad address in text read] " __e7_: .asciiz " [Bad address in data/stack read] " __e8_: .asciiz " [Error in syscall] " __e9_: .asciiz " [Breakpoint] " __e10_: .asciiz " [Reserved instruction] " __e11_: .asciiz "" __e12_: .asciiz " [Arithmetic overflow] " __e13_: .asciiz " [Inexact floating point result] " __e14_: .asciiz " [Invalid floating point result] " __e15_: .asciiz " [Divide by 0] " __e16_: .asciiz " [Floating point overflow] " __e17_: .asciiz " [Floating point underflow] " __excp: .word __e0_,__e1_,__e2_,__e3_,__e4_,__e5_,__e6_

.word __e7_,__e8_,__e9_,__e10_,__e11_,__e12_

.word __e13_,__e14_,__e15_,__e16_,__e17_ s1: .word 0 #para salvar registros de usuario. s2: .word 0 .ktext 0x80000080 #ExcAdd # Al entrar se pueden usar los registros k0 y k1, sin salvarlos, ya que el usuario # no puede usar estos registros. .set noat move $k1, $at # Salva at ya que el manipulador usa macros. .set at #Habilita uso de macros en modo kernel. #El manipulador usa v0 y a0, los salva en memoria de datos del kernel. #No usa el stack ya que la excepción puede ser una mala referencia al stack. #Asume que no es confiable el valor de sp. sw $v0, s1 sw $a0, s2 #Salva a0 y v0 en variables locales del kernel. mfc0 $k0, $13 # Cause es el registro $13 del coprocesador 0

sgt $v0 , $k0, 0x44 # Ignora la excepción, mayor que causa 17. bgtz $v0, ret addu $0, $0, 0 # Equivale a un nop. Se ejecuta(delayed branch).

li $v0, 4 # syscall 4 (print_str con mensaje m1) la $a0, __m1_




syscall li $v0, 1 # syscall 1 (print_int)

srl $a0, $k0, 2 # Genera en a0 el número de la excepción, syscall # y lo imprime. li $v0, 4 # syscall 4 (print_str) lw $a0, __excp($k0) #Accesa dirección mensaje de error. syscall bne $k0, 0x18, ok_pc # Causa = 6. Bad PC requires special checks mfc0 $a0, $14 # a0 = EPC and $a0, $a0, 0x3 # Is EPC word-aligned? beq $a0, $zero, ok_pc li $v0, 10 # Exit on really bad PC (out of text). syscall ok_pc: li $v0, 4 # syscall 4 (print_str) la $a0, __m2_ syscall mtc0 $zero, $13 # Clear Cause register ret: lw $v0, s1 # Recupera a0 y v0. lw $a0, s2 mfc0 $k0, $14 # k0 = EPC .set noat move $at, $k1 # Restaura $at del usuario. .set at # Habilita macros de usuario. rfe # Return from exception handler addiu $k0, $k0, 4 # Return to next instruction jr $k0 # Standard startup code. #Invoke the routine main with no arguments. .text .globl __start __start: lw $a0, 0($sp) # argc addiu $a1, $sp, 4 # argv addiu $a2, $a1, 4 # envp sll $v0, $a0, 2 addu $a2, $a2, $v0 jal main li $v0, 10 # syscall 10 (exit) syscall




Observaciones: a) La instrucción: sgt $v0, $k0, 0x44 # ignore interrupt exceptions es una macro, que expandida resulta: ori $at, $zero, 0x44 slt $v0, $at, $k0 #coloca 1 en v0 si 0x44 < k0 0x44 equivale al binario 1000100, con número de excepción binario 10001(ya que los dos últimos son ceros). Es decir si la causa de excepción es mayor que 17 ignora la excepción. b) La macro: lw $a0, __excp($k0) #Accesa dirección mensaje de error. Accesa al arreglo de punteros, que contienen los mensajes asociados a la causa de la excepción. En k0 está la causa de la excepción, considerando que los dos bits menos significativos son ceros se tiene, por ejemplo, que cuando k0 tiene valor binario 11000, se tendrá la causa 6(110). Y se suma a la dirección dada por __excp el valor decimal 24(equivale a 11000); el cual equivale a 6*4. Es decir la sexta entrada con valor simbólico: __e6_. c) Los rótulos del kernel usan el símbolo underscore( _ ), de esta forma el ensamblador difícilmente puede tener conflicto con los símbolos de usuario. d) La instrucción rfe, restaura el registro de estado como estaba antes de la excepción y

reanuda la ejecución en la instrucción siguiente a la que causó la excepción.

Documents

cap13profesores.elo.utfsm.cl/~tarredondo/info/comp-architecture/apuntes-lsb/cap13.pdfTitle: Microsoft Word - cap13.doc Created Date: 9/3/2004 9:48:48 AM