“Estancado en la suma de dos matrices utilizando instrucciones MMX en NASM.”
Me dieron la siguiente tarea:
Dadas dos arrays con 16 elementos: NIZA RESW 16 y NIZB RESW 16 \
almacene en el tercer array (NIZC RESW 16) los siguientes valores: NIZC[i]=NIZA[i]+NIZB[i] usando instrucciones MMX y compilándolo con NASM
Esto es lo que tengo hasta ahora:
%include "apicall.inc"
%include "print.inc"
segment .data
unos1 db "Array A: ", 0
unos2 db "Array B: ", 0
ispisC db "Array C : ", 0
segment .bss
NIZA RESW 16
NIZB RESW 16
NIZC RESW 16
segment .text
global start
start:
call init_console
mov esi,0
mov ecx, 16
mov eax, unos1
call print_string
call print_nl
unos_a:
call read_int
mov [NIZA+esi], eax
add esi, 2
loop unos_a
mov esi,0
mov ecx, 16
mov eax, unos2
call print_string
call print_nl
unos_b:
call read_int
mov [NIZB+esi], eax
add esi, 2
loop unos_b
movq mm0, qword [NIZA]
movq mm1, qword [NIZB]
paddq mm0, mm1
movq qword [NIZC], mm0
mov esi,NIZC
mov ecx,16
mov eax, ispisC
call print_string
call print_nl
ispis_c:
mov ax, [esi]
movsx eax, ax
call print_int
call print_nl
add esi, 2
loop ispis_c
APICALL ExitProcess, 0
Después de compilar el array dado y probarlo con los siguientes dos arrays, el tercer array solo almacena 4 elementos de 16. (dado en la siguiente imagen)
¿Alguien sabe por qué solo almacena 4 elementos de 16? Cualquier ayuda es apreciada. \
Si tiene alguna pregunta sobre las funciones print_string, print_int y print_nl son funciones para imprimir una cadena, una nueva línea y un entero al empujarlo en el registro EAX, y también tenga en cuenta que este es un programa de 32 bits.
davy.ai
Basándose en el código proporcionado, parece que solo se está actualizando el primer bloque de 8 bytes del registro mm0 con el resultado de la suma. Esta es la probable razón por la que solo se están actualizando correctamente los primeros 4 elementos del tercer array.
Para solucionar este problema, es necesario realizar la operación de suma en cada bloque de 8 bytes de los arrays individualmente. Una forma de lograr esto es usando un ciclo que itere sobre los 16 elementos de los arrays, sumándolos uno por uno. Aquí hay una implementación de ejemplo:
Este código carga el primer bloque de 8 bytes de NIZA y NIZB en mm0 y mm1, respectivamente. Luego establece punteros al siguiente bloque de 8 bytes de NIZA, NIZB y NIZC, e ingresa a un ciclo que suma los elementos correspondientes de NIZA y NIZB, almacena el resultado en NIZC, e incrementa los punteros en 8 bytes. El ciclo se repite para los 16 elementos de los arrays, y después de la última iteración, se almacena el resultado de la última suma en NIZC.
Tenga en cuenta que este código asume que los arrays están alineados en límites de 8 bytes, como se requiere en el conjunto de instrucciones MMX. Si los arrays no están alineados, es posible que deba ajustar el código en consecuencia.