198 lines
7.4 KiB
Plaintext
198 lines
7.4 KiB
Plaintext
# danza papier
|
|
lang=es
|
|
baile colaborativo que ejemplifica una arquitectura computacional común, basada en la wdr papiercomputer
|
|
|
|
=> https://wiki.xxiivv.com/site/papier.html papier computer
|
|
=> ./computer_architecture.gmi {computer architecture}
|
|
|
|
parte de {las danzas}
|
|
|
|
para la versión no bailada pero también no electrónica, ve {computadora de papel}
|
|
|
|
# componentes
|
|
|
|
## participantes
|
|
|
|
la arquitectura base consta de al menos 6 personas:
|
|
|
|
* PC: apuntadora del programa (program counter)
|
|
* Memoria: quien administra la lista de números correspondiente al programa
|
|
* CU: la directora, unidad de control
|
|
* Rn: al menos dos registros, R0 y R1
|
|
* LU: la que responde preguntas lógicas
|
|
|
|
|
|
## materiales
|
|
|
|
como materiales tangibles solo se requiere la lista de números que administra la Memoria.
|
|
|
|
como sea, si el grupo cuenta con suficientes personas, cada uno de esos números puede ser cuerpeado por una persona distinta.
|
|
|
|
opcionalmente, puede existir una tabla en papel que sirva de recordatorio a la CU de las operaciones a seguir: el microcódigo.
|
|
|
|
|
|
## movimientos
|
|
|
|
se necesita contar con, y conocer, el siguiente conjunto de movimientos.
|
|
|
|
### todas las personas
|
|
|
|
* dígito-movimiento: un movimiento por cada digito en la base elegida (por ejemplo, del 0 al 9 para trabajar en base 10)
|
|
* posición: una forma de indicar si un dígito es el primero o el segundo
|
|
* finalización: un movimiento que indique que el cómputo ha terminado
|
|
|
|
será importante conocer cuál es el movimiento siguiente y anterior a cada dígito-movimiento.
|
|
|
|
### Registros y CU:
|
|
|
|
* indicación de incremento
|
|
* indicación de decremento
|
|
|
|
### LU y CU:
|
|
|
|
* pregunta: ¿el contenido del Registro es 0?
|
|
* respuestas: sí, no
|
|
|
|
### PC y CU:
|
|
|
|
* indicación de incremento sencillo
|
|
* indicación de incremento doble
|
|
|
|
|
|
## instrucciones
|
|
|
|
la computadora cuenta con los 5 siguientes códigos de operación (entre paréntesis su mnemónico)
|
|
|
|
* 0: Fin del programa (FIN)
|
|
* 1: Condicional (CND)
|
|
* 2: Salta a (SLT)
|
|
* 3: Incrementa (INC)
|
|
* 4: Decrementa (DEC)
|
|
|
|
una instrucción completa consiste de ese código de operación, acompañada de un dígito llamado argumento.
|
|
|
|
ese argumento tiene un significado distinto según la instrucción:
|
|
|
|
* FIN: argumento ignorado
|
|
* CND: el argumento es el número de Registro al cual preguntarle si es 0: si la respuesta es sí, hay que saltarse una instrucción, y si la respuesta es no, hay que continuar normalmente
|
|
* SLT: el argumento es el número de línea a la cual saltar a continuación
|
|
* INC: el argumento es el número de Registro que ha de incrementarse
|
|
* DEC: el argumento es el número de Registro que ha de decrementarse
|
|
|
|
|
|
# ciclo de instrucción
|
|
|
|
la máquina estará en el llamado ciclo de instrucción hasta encontrar a una instrucción FIN.
|
|
|
|
este ciclo consiste de dos partes, fetch (buscar) y execute (ejecutar).
|
|
|
|
antes de comenzar, hay que realizar una inicialización:
|
|
|
|
* PC toma el dígito-movimiento correspondiente a 0, y se mueve transmitiéndolo
|
|
* Registros toman el dígito-movimiento inicial que se les indique, y se mueven transmitiéndolo
|
|
|
|
## fetch (buscar)
|
|
|
|
* todes les Registros se mueven con una amplitud normal, transmitiendo sus dígitos-movimientos
|
|
* PC se mueve transmitiendo el dígito-movimiento que tiene almacenado
|
|
* Memoria recibe el dígito, y busca en su lista de números al par de dígitos que se encuentran en esa posición.
|
|
* Memoria se mueve transmitiendo esos dos dígitos-movimientos, con cuidad de indicar cuál es el primero y cuál es el segundo
|
|
* CU recibe esos dos dígitos
|
|
* la máquina pasa a la etapa execute
|
|
|
|
|
|
## execute (ejecutar)
|
|
|
|
* CU identifica al primer dígito recibido como código de operación, y al segundo como argumento
|
|
* de acuerdo al código de operación, suceden las siguientes operaciones:
|
|
|
|
### FIN: Fin del programa (0)
|
|
|
|
* CU se mueve indicando finalización
|
|
* todes se detienen excepto Registros que continúan con sus dígitos-movimientos
|
|
|
|
les Registros ahora pueden ser inspeccionados para leer los resultados del cómputo.
|
|
|
|
### CND: Condicional (1)
|
|
|
|
* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento
|
|
* Registros reciben el dígito
|
|
* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando
|
|
* les demás Registros reducen la amplitud de su propio dígito-movimiento.
|
|
* CU se mueve preguntando a LU si el Registro es 0.
|
|
* LU recibe la pregunta, y observa al Registro con movimiento amplio
|
|
* LU se mueve respondiendo sí o no
|
|
* CU recibe la respuesta de LU
|
|
* CU se mueve dirigéndose a PC: si la respuesta que recibió de LU fue sí, entonces se mueve indicando un doble incremento; si la respuesta fue no, entonces se mueve indicando un incremento sencillo
|
|
* PC recibe la indicación, y pasa al siguiente dígito-movimiento, ya sea una o dos veces según lo recibido.
|
|
* la máquina pasa a la etapa fetch
|
|
|
|
|
|
### SLT: Salta a (2)
|
|
|
|
* CU se mueve dirigéndose a PC, transmitiendo el dígito-movimiento que recibió como argumento
|
|
* PC recibe el dígito y lo almacena, reemplazando al dígito-movimiento que estaba realizando antes.
|
|
* la máquina pasa a la etapa fetch
|
|
|
|
|
|
### INC: Incrementa (3)
|
|
|
|
* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento
|
|
* Registros reciben el dígito
|
|
* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando
|
|
* les demás Registros reducen la amplitud de su propio dígito-movimiento.
|
|
* CU se mueve dirigiéndose a les Registros, transmitiendo la indicación de incremento
|
|
* Registro con el movimiento amplio, pasa al dígito-movimiento siguiente al que estaba realizando (incrementa en 1 al valor que estaba almacenando)
|
|
* les demás Registros hacen caso omiso
|
|
* CU se mueve dirigéndose a PC, indicando un incremento sencillo
|
|
* PC recibe la indicación, y pasa al siguiente dígito-movimiento
|
|
* la máquina pasa a la etapa fetch
|
|
|
|
|
|
### DEC: Decrementa (4)
|
|
|
|
* CU se mueve dirigiéndose a les Registros, transmitiendo el dígito-movimiento que recibió como argumento
|
|
* Registros reciben el dígito
|
|
* Registro que tiene a ese dígito en su nombre, hace más evidente el dígito-movimiento que estaba realizando
|
|
* les demás Registros reducen la amplitud de su propio dígito-movimiento.
|
|
* CU se mueve dirigiéndose a les Registros, transmitiendo la indicación de decremento
|
|
* Registro con el movimiento amplio, pasa al dígito-movimiento anterior al que estaba realizando (decrementa en 1 al valor que estaba almacenando)
|
|
* les demás Registros hacen caso omiso
|
|
* CU se mueve dirigéndose a PC, indicando un incremento sencillo
|
|
* PC recibe la indicación, y pasa al siguiente dígito-movimiento
|
|
* la máquina pasa a la etapa fetch
|
|
|
|
|
|
# ejemplo de programa
|
|
|
|
este programa suma los dígitos en R0 y R1, colocando el resultado en R0
|
|
|
|
## lista de números
|
|
|
|
este es el programa en formato de lista de números para que administre Memoria.
|
|
|
|
* 0: 2 3
|
|
* 1: 4 1
|
|
* 2: 3 0
|
|
* 3: 1 1
|
|
* 4: 2 1
|
|
* 5: 0 0
|
|
|
|
el primer dígito en la lista es el número de línea.
|
|
|
|
los dos dígitos siguientes son el primer y segundo dígitos de instrucción
|
|
|
|
|
|
## ensamblador
|
|
|
|
usando las palabras clave (mnemónicos) para indicar los códigos de operación, el programa se vería así:
|
|
|
|
* 0: SLT 3 (salta a la línea 3)
|
|
* 1: DEC 1 (decrementa R1)
|
|
* 2: INC 0 (incrementa R0)
|
|
* 3: CND 1 (¿R1 es 0? si sí, salta una instrucción, si no, continúa)
|
|
* 4: SLT 1 (salta a la línea 1)
|
|
* 5: FIN 0 (fin del programa)
|
|
|
|
(esta forma de programar es a la que se refiere la práctica de {s-camino})
|