Actividad #12

public class interfaz implements Runnable {

public static void main(String[] args) {
String mensaje = "";
byte opcion = 1;

System.out.print(" mensaje 100 veces\n"
+ " mensaje: ");
mensaje = new Scanner(System.in).next();
System.out.print("\n\n1) Con procedimiento\n2) Sin procedimiento\n: ");
opcion = new Scanner(System.in).nextByte();

Proc proc=new Proc();
new Thread(new interfaz()).start();
new Thread(proc).start();

if (opcion == 1) {
new interfaz().procedimiento(mensaje, 0);
} else if (opcion == 2) {
for (int i = 0; i < 100; i++) {
System.out.println(mensaje);
}
} else {
System.err.println("Opcion no valida!");
}
System.out.println("Tiempo: " + proc.paraYDevuelve()+ " milisegundos");
}

public void procedimiento(String mensaje, int iteracion) {
System.out.println(mensaje);
if (iteracion < 100) procedimiento(mensaje, iteracion + 1);
}

@Override public void run() {}
}

class Proc implements Runnable {
private boolean continua = true;
private int contador = 0;

public int paraYDevuelve() {
continua = false;
return contador;
}

@Override public void run() {
do {
try {
Thread.sleep(1);
} catch (InterruptedException ex) {
Logger.getLogger(interfaz.class.getName()).log(Level.SEVERE, null, ex);
}
contador++;
} while (continua);
}
}

 

Con proceso

 

Sin proceso

Actividad #11

La diferencia entre un procedimiento y un macro, es que los procedimientos leen línea por línea el código, y los macros no, los procedimientos usan la sentencia call para ser llamados en caso de que no esten implícitos en el código, y los macros utilizan la sentencia include cuando son externos al programas, tomando un conjunto de instrucciones que ya estan definidas y solo se ejecutan tal y como estan.
PROCEDIMIENTOS


SUM2DW_P.ASM
;
; Este programa suma dos variables de tipo palabra doble
; y guarda el resultado en una variable de tipo palabra
; doble. Este programa utiliza un procedimiento para
; efectuar la suma.
;
; El pseudocódigo de este programa es:
;
; DX:AX = dato1
; CX:BX = dato2
;
; suma2dw()
;
; resul = DX:AX
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
ideal
dosseg
model small
stack 256
;****** VARIABLES DEL PROGRAMA ****************************
dataseg
codsal db 0
dato1 dd ?
dato2 dd ?
resul dd ?
;****** CÓDIGO DEL PROGRAMA *******************************
codeseg
inicio:
mov ax, @data ; Inicializa el
mov ds, ax ; segmento de datos
mov ax, [word dato1] ; DX:AX = dato1
mov dx, [word dato1+2]
mov bx, [word dato2] ; CX:BX = dato2
mov cx, [word dato2+2]
; Llama al procedimiento para efectuar la suma
call suma2dw ; suma2dw()
mov [word resul], ax ; resul = DX:AX
mov [word resul+2], dx
salir:
mov ah, 04Ch
mov al, [codsal]
int 21h
;****** PROCEDIMIENTOS ************************************
;**********************************************************
; SUMA2DW
;
; Este procedimiento suma dos variables de tipo
; palabra doble.
;
; Parámetros:
;
; DX:AX = Primer sumando
; CX:BX = Segundo sumando
;
; Regresa:
;
; DX:AX = Suma
;
; El pseudocódigo de este procedimiento es:
;
; DX:AX += CX:BX
;**********************************************************
proc suma2dw
add ax, bx ; DX:AX += CX:BX
adc dx, cx
ret ; Regresa del
; procedimiento
endp suma2dw
;****** CÓDIGO DE TERMINACIÓN *****************************
end inicio

;**********************************************************
; SWAPNIBL2.ASM
;
; Este programa intercambia los MSN y LSN de una variable
; de un byte. El resultado queda en la misma variable.
; Este programa utiliza un procedimiento para intercambiar
; los nibles.
;
; El pseudocódigo de este programa es:
;
; AL = dato
; swapnibl()
; dato = AL
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
ideal
dosseg
model small
stack 256
;****** VARIABLES DEL PROGRAMA ****************************
dataseg
codsal db 0
dato db ?
;****** CÓDIGO DEL PROGRAMA *******************************
codeseg
inicio:
mov ax, @data ; Inicializa el
mov ds, ax ; segmento de datos
mov al, [dato] ; AL = dato
; Llama al procedimiento para intercambiar los nibles
call swapnibl ; swapnibl()
mov [dato], al ; dato = AL
salir:
mov ah, 04Ch
mov al, [codsal]
int 21h
;****** PROCEDIMIENTOS ************************************
;**********************************************************
; SWAPNIBL
;
; Este procedimiento intercambia los MSN y LSN de una
; variable de un byte.
;
; Parámetro:
;
; AL = dato
;
; Regresa:
;
; AL = dato con los nibles intercambiados.
;
; El pseudocódigo de este procedimiento es:
;
; CL = 4
; rol al, 4
;**********************************************************
proc swapnibl
push cx ; Preserva CX
mov cl, 4
rol al, cl
pop cx ; Recupera CX
ret
endp swapnibl
;****** CÓDIGO DE TERMINACIÓN *****************************
end inicio


MACROS
;Programa que muestra un marco desde la coordenada (Fila1,Columna1) hasta la (Fila2,Columna2)
;El programa, utiliza macros. funciona con LOOP. y utiliza la función 02h de la interreucipon 21h
;02:15 p.m. Miercoles, 18 de Octubre de 2006
MARCO MACRO FILA1, COL1, FILA2, COL2
LOCAL LINE_TOP
LOCAL EXIT_TOP
LOCAL LINE_BOTTOM
LOCAL EXIT_BOTTOM
LOCAL LINE_LEFT
LOCAL EXIT_LEFT
LOCAL LINE_RIGHT
LOCAL EXIT_RIGHT
;Recorremos desde COL2 hasta COL1 en FILA1
MOV cl,COL2 ;El contador decrementará desde COL2
LINE_TOP: ;
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,fila1 ;Row
MOV DL,cl ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write attributes/characters at cursor position (Int 10/09)
MOV DL,'+' ;Character
INT 21H ;

CMP Cl,COL1
je EXIT_TOP
LOOP LINE_TOP ;dec cx;cmp cx,0;jne line_left;
EXIT_TOP:

;Recorremos desde COL2 hasta COL1 en FILA2
MOV cl,col2
LINE_BOTTOM:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,fila2 ;Row
MOV DL,cl ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,COL1
je EXIT_BOTTOM
LOOP LINE_BOTTOM ;dec cx;cmp cx,0;jne line_left;
EXIT_BOTTOM:

;Recorremos desde FILA2 hasta FILA1 en COL1
MOV cl,FILA2
LINE_LEFT:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,cl ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,FILA1
je EXIT_LEFT
LOOP LINE_LEFT ;dec cx;cmp cx,0;jne line_left;
EXIT_LEFT:

;Recorremos desde FILA2 hasta FILA1 en COL2
MOV cl,FILA2
LINE_RIGHT:
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,cl ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'+' ;Character
INT 21H

CMP Cl,FILA1
je EXIT_RIGHT
LOOP LINE_RIGHT ;dec cx;cmp cx,0;jne line_left;
EXIT_RIGHT:

;Dibujamos esquinas
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA1 ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA1 ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA2 ;Row
MOV DL,COL1 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

MOV AH,02h ;Set cursor position (Int 10/02)
MOV DH,FILA2 ;Row
MOV DL,COL2 ;Column
MOV BH,0 ;page number: 0 = in graphics modes
int 10h ;Video (Int 10)

MOV AH,02h ;Write characters only at cursor position (Int 10/0A)
MOV DL,'@' ;Character
INT 21H

ENDM

CLS MACRO ;Clear Screen
MOV AH, 00H ;Set video mode
MOV AL, 03H ;Video mode 80x25, 8x8, 16, 4, B800, CGA
INT 10H ;Video (Int 10)
ENDM

.model small
.stack
.code
.startup

CLS
MARCO 1,1,22,78
MARCO 5,15,15,25
MARCO 3,3,8,8
MARCO 3,30,18,70

;Enviar cursor a ultima línea
MOV AH,02h ;Set cursor position (Int 10/02)
MOV DX,1700H ;Row & Col
MOV BH,0 ;Page number: 0 = in graphics mode
int 10h

.exit
end

Preguntas

Actividad Martes 5

Calcular el numero mayor y el menor

 

 

Menor

 

 

Ejercicios en ensamblador

Se pretende realizar un programa en lenguaje ensamblador equivalente al siguiente código en C:

#include <iostream.h>

main()
{

int a[] = {12, 5, 34, 75, 10, 25};
int n = 6;
int max, i;
for (max = i = 0; i < n; i++)
if (a[i] > max)
max = a[i];
cout << max << end1;
}

Analisis en cuaderno

Código  en ensamblador

Aplicacion de DEBUG

Ejercicio # 2

#2: (Implementación de la condición if-then-else) Se pretende realizar un programa en lenguaje ensamblador equivalente al siguiente código en C:#include <iostream.h>
main()
{
int a[] = {-12, 5, -34, -75, -10, 25};
int n = 6;
int max, i;
int npos, nneg;
for (i = npos = nneg = 0; i < n; i++)
if (a[i] > 0)
npos++;
else
nneg++;
cout << “+: “ << npos << “; -: “ << nneg << end1;
}

Analisis

En el programa se utiliza las variables npos y nneg,max despues se utiliza el .DATA en
el codigo del lengujes ensamblador. despues moviendo axa ds y despues cargar los valores de a en SI, para despues
utilizar el ciclo que compara cada uno de los datos del arreglo a
con cero, y asi determinar si es positivo o negativo y asi ir agregando los valores en las variables npos y nneg.

 

 Código en ensamblador

 

Debug

Desplazamiento, Rotación y Adeudos

Desplazamiento, Rotación y Adeudos


Las instrucciones de corrimiento, que son parte de la capacidad lógica de la computadora, pueden realizar las siguientes acciones:

1. Hacer referencia a un registro o dirección de memoria.
2. Recorre bits a la izquierda o a la derecha.
3. Recorre hasta 8 bits en un byte, 16 bits en una palabra y 32 bits en una palabra doble.
4. Corrimiento lógico (sin signo) o aritmético (con signo).


El segundo operando contiene el valor del corrimiento, que es una constante (un valor inmediato) o una referencia al registro CL. Para los procesadores 8088/8086, la constante inmediata solo puede ser 1; un valor de corrimiento mayor que 1 debe estar contenido en el registro CL. Procesadores posteriores permiten constantes de corrimiento inmediato hasta 31.



DESPLAZAMIENTO O CORRIMIENTO DE BITS HACIA LA DERECHA.
Los corrimientos hacia la derecha (SHR y SAR) mueven los bits hacia la derecha en el registro designado. El bit recorrido fuera del registro mete la bandera de acarreo. Las instrucciones de corrimiento a la derecha estipulan datos lógicos (sin signo) o aritméticos (con signo):

Las siguientes instrucciones relacionadas ilustran SHR y datos con signo:

INSTRUCCION COMENTARIO
MOV CL, 03
MOV AL, 10110111B ; AL = 10110111
SHR AL, 01 ; AL = 01011011 Un corrimiento a la derecha
SHR AL, CL ; AL = 00001011 Tres corrimientos adicionales a la derecha

El primer SHR desplaza el contenido de AL un bit hacia la derecha. El bit de mas a la derecha es enviado a la bandera de acarreo, y el bit de mas a la izquierda se llena con un cero. El segundo SHR desplaza tres bits más a AL. La bandera de acarreo contiene de manera sucesiva 1, 1 y 0; además, tres bits 0 son colocados a la izquierda del AL.


SAR se difiere de SHR en un punto importante: SAR utiliza el bit de signo para llenar el bit vacante de más a la izquierda. De esta manera, los valores positivos y negativos retienen sus signos. Las siguientes instrucciones relacionadas ilustran SAR y datos con signo en los que el signo es un bit 1:

En especial, los corrimientos a la derecha son útiles para (dividir entre 2) obtener mitades de valores y son mucho más rápidas que utilizar una operación de división. Al terminar una operación de corrimiento, puede utilizar la instrucción JC (Salta si hay acarreo) para examinar el bit desplazado a la bandera de acarreo.



DESPLAZAMIENTO O CORRIMIENTO DE BITS A LA IZQUIERDA.


Los corrimientos hacia la izquierda (SHL y SAL) mueven los bits a la izquierda, en el registro designado. SHL y SAL son idénticos en su operación. El bit desplazado fuera del registro ingresa a la bandera de acarreo. Las instrucciones de corrimiento hacia la izquierda estipulan datos lógicos (sin signo) y aritméticos (con signo):

SHL: Desplazamiento lógico a la izquierda SAL: Desplazamiento aritmético a la izquierda




Las siguientes instrucciones relacionadas ilustran SHL para datos sin signo:

INSTRUCCION COMENTARIO
MOV CL, 03
MOV AL, 10110111B ; AL = 10110111
SHL AL, 01 ; AL = 01101110 Un corrimiento a la izquierda
SHL AL, CL ; AL = 01110000 Tres corrimientos mas

El primer SHL desplaza el contenido de AL un bit hacia la izquierda. El bit de más a la izquierda ahora se encuentra en la bandera de acarreo, y el último bit de la derecha del AL se llena con cero. El segundo SHL desplaza tres bits más a AL. La bandera de acarreo contiene en forma sucesiva 0, 1 y 1, y se llena con tres ceros a la derecha del AL.


Los corrimientos a la izquierda llenan con cero el bit de mas a la derecha. Como resultado de esto, SHL y SAL don idénticos. Los corrimientos a la izquierda en especial son útiles para duplicar valores y son mucho más rápidos que usar una operación de multiplicación.


Al terminar una operación de corrimiento, puede utilizar la instrucción JC (Salta si hay acarreo) para examinar el bit que ingreso a la bandera de acarreo.



ROTACIÓN A LA DERECHA DE BITS
Las rotaciones a la derecha (ROR y RCR) desplazan a la derecha los bits en el registro designado. Las instrucciones de rotación a la derecha estipulan datos lógicos (sin signo) o aritméticos (con signo):


Las siguientes instrucciones relacionadas ilustran ROR:


INSTRUCCION COMENTARIO
MOV CL, 03
MOV BH, 10110111B ; BH = 10110111
ROR BH, 01 ; BH = 11011011 Una rotación a la derecha
ROR BH, CL ; BH = 00001011 Tres rotaciones a la derecha


El primer ROR desplaza el bit de más a la derecha del BH a la posición vacante de más a la izquierda. La segunda y tercera operaciones ROR realizan la rotación de los tres bits de mas a la derecha.


RCR provoca que la bandera de acarreo participe en la rotación. Cada bit que se desplaza fuera de la derecha se mueve al CF y el bit del CF se mueve a la posición vacante de la izquierda.


ROTACIÓN A LA IZQUIERDA DE BITS
Las rotaciones a la izquierda (ROL y RCL) desplazan a la izquierda los bits del registro designado. Las instrucciones de rotación a la izquierda estipulan datos lógicos (sin signo) y aritméticos (con signo):

Las siguientes instrucciones relacionadas ilustran ROL:


INSTRUCCION COMENTARIO
MOV CL, 03
MOV BL, 10110111B ; BL = 10110111
SHR BL, 01 ; BL = 11011011 Una rotación a la izquierda
SHR BL, CL ; BL = 00001011 Tres rotaciones a la izquierda

El primer ROL desplaza el bit de mas a la izquierda del BL a la posición vacante de mas a la derecha. La segunda y tercera operaciones ROL realizan la rotación de los tres bits de mas a la izquierda.


De manera similar a RCR, RCL también provoca que la bandera de acarreo participe en la rotación. Cada bit que se desplaza fuera por la izquierda se mueve al CF, y el bit del CF se mueve a la posición vacante de la derecha.

Hacer manualmente la ejecución y comprobar con el debug