Question

Write a MIPS program to that will take two 4x4 matrices, and calculate their sum and product, using row major, and column major math (so this is actually 4 problems, but obviously they’re all pretty related).

I generated two sample arrays to test

2   1       9       2 7   9       10      10 3   4       4       4 2   5       4       4

8 7 1 2 2 7 8 6 7 5 6 8 9 4 8 9

The output of your program will be another 4x4 matrix, which you should print off. Don’t ask the user to input 16 numbers, just hard code some arrays

Answer 1

Program:

rowcol_major. asm .data word 2,1,9,2 A: . word 7,9,10,10 word 3,4,4,4 word 2,5,4,4 word 8,7,1,2 В: word 2,7,8,6 word 7,5,6,8 word 9,4,8,9 C: word 0:4 word 0:4 word 0:4 word 0:4 messagel:.asciiz "A-\n" message2:.asciiz "B=\ n" message3:.asciiz "Using row major, C- A+ B = \n" message4:.asciiz "Using column major, C- AxB - \ n" message5:.asciiz "Using row major, C- AxB = \n" message6:. asciiz "Using column major, C -AxB - \n " asciiz space: newline: n" asciiz .text main: li v0,4 la $a0,messagel syscall #Print matrix A la $a0,A li al,4 li a2,4 jal printmatrix li v0,4 la a0,message2 Pass base address of A to printmna trix #Pass ro size # Pass column size syscall #Print matrix B la a0,B li al,4 li a2,4 # pass address of the ma trix B to printma trix # Pass rOw size # Pass column size jal printmatrix Test add Rowmajor #Add A and B using row major and save the result in C li a0,4 la al,A la a2,B la a3,C jal add_Rowmajor Pass row size (and column size) to mul Rowmajor # Pass base address of A # Pass base address of B #Pass base address of C # Call add Rowmajor

#Print resultant matrix C li v0,4 la a0,message3 syscall # pass address of the matrix C to printmatrix #Pass ro size # Pass column size Call printma trix la a0,C li al,4 li a2,4 jal printmatrix Test add Colmajor #Add A and B using column major and save the result in C li a0,4 la al,A la a2,B la a3,C jal add_Colmajor #Print resultant matrix C li v0,4 la a0,message4 syscall la a0,C Pass row size (and column size) to mul Rowmajor #Pass base address of A # Pass base address of B Pass base address of C Call add Colmajor # pass address of the matrix C to printma trix Pass ro size # Pass column size Call printma trix li al,4 li a2,4 jal printmatrix # Test mul Rowmajor #Multiply A and B using row major and save the result in C li a0,4 la al,A la a2,B la a3,C jal mul Rowmajor #Print resul tant matrix C li v0,4 la a0,message5 syscall la a0,C li al,4 li a2,4 jal printmatrix Test mul Colmajor #Multiply A and B using column major and save the result in C li a0,4 la al,A la a2,B la a3,C jal mul Colmajor #Print resultant matrix C li v0,4 la a0,message6 syscall la a0,C li al,4 li a2,4 jal printmatrix #exit li v0, 10 Pass row size (and column size) to mul Rowmajor # Pass base address of A #Pass base address of B Pass base address of C # Call mul Rowmajor pass address of the matrix C to printmatrix #Pass ro size # Pass column size Call printma trix Pass row size (and column size) to mul Rowmajor #Pass base address of A # Pass base address of B Pass base address of C Call mul Colmajor # pass address of the matrix C to printmatrix # Pass row size # Pass column size # Call printma trix # End the program syscall

#Procedure to add two matrices using row major add Rowmajor # i-0 j-0 calculate the offset of element at [i] [jl li t0,0 li tl,0 mul t2,$t0,$a0 add t2,t2,tl sll t2,t2,2 addr loopl: addr loop2: add t3,t2,G al lw t4, t3) add t3,t2,G a2 lw t5, (t3) st4=A[i] [i] st5-B [il i st4-A[i] [il+B [i] [i] add t4,t4,4 t5 add t3,t2,$ a3 $t4, ($t3) C[i] [i1-A[i] [i] +B [i] [i] SW add tl,tl,l beq tl,4, addr next j addr loop2 add t0,t0,1 beq t0,4, return_add_Rowmajor # if i=4 and j- 4 j addr_loopl # j =j+1 if j-4, exit the inner loop # i-i+ 1 addr next: exit the outer loop #Return to main program return add Rowmajor: jr $ra #Procedure to add two matrices using column major add Colmajor # j -0 # i-0 li tl,0 li t0,0 mul t2,$t0,$a0 add t2,t2,$tl sll t2,t2,2 addc loopl: addc loop2: calculate the offset of element at [i] [jl add t3,t2,G al lw t4, (t3) add t3,t2,$a2 lw t5, (t3) # St4=A [i] [i] st5=B [i] [il st4-A[i] [il+B [i] [i] add t4,t4,G t5 add $t3,t2, G a3 sw t4, ($t3) C[il lil-A[i] [i] +B [i] [j] add t0,to,1 beq t0,4, addc next # if j- 4 , exit the inner loop jaddc loop2 add $tl,tl,1 beq stl,4,return add Colmajor # if i=4 and j-4, exit the outer loop jaddc_loopl i=i+1 j-j+1 addc next: #Return to main program return add Colmajor: jr $ra

#Procedure to multiply two matrices using row major mul Rowmajor: # i-0 j-0 li t0,0 li stl,0 li $t3,0 mulr loopl: mulr loop2: #0 li t7,0 mul t2,t0,a0 add $t2,st2,st3 sll t2,st2,2 add t4,$t2,G al lw t4, ($t4) # sum-0 calculate the offset of element A[i] [k] mulr loop3: multiply with storage size calculate the offset of element at B[k] [j] mul t2,t3,$a0 add t2,t2,$tl sll t2,$t2,2 add t5,t2,a2 lw t5, (t5) multiply with storage size mul $t4,$t4, $ t5 add $t7,t7,$ t4 add t3,t3,1 beq t3,a0,mulr nextl j mulr_loop3 mulr next1: calculate the offset of element at [i] [i1 mul $t2,4t0,a0 add t2,t2,stl sll t2,t2,2 add t3,t2,$ a3 $t7, ($t3) multiply with storage size C[i] [i]sum or A[i] [k] *B [k] [il SW add tl,tl,l beq tl,$a0,mulr_next2 j mulr loop2 add t0,sto,1 beq t0,a0,return mul Rowmajor # if i - 4 and j-4 , exit the outer loop j mulr loopl #j-j+1 # if j- 4, exit the innner loop # i-i+ 1 mulr next2: #Return to main program return mul Rowmajor: jr $ra

#Procedure to add two matrices using rOw major mul Colmajor: li tl,0 li st0,0 #j-0 # i-0 mulc loop1: mulc loop2: li t3,0 li t7,0 mul $t2,$t0,$ a0 add t2,t2,$t3 sll t2,t2,2 add t4,t2,al 1w t4, (t4) # k- 0 # sum-0 calculate the offset of element A[i] [k] mulc loop3: multiply with storage size calculate the offset of element at B[k] [j] mul t2,t3,$ a0 add t2,t2,$tl sll t2,t2,2 # multiply with storage size add t5,t2,$ a2 1w t5, (t5) mul t4,$t4, $ t5 add t7,st7,$t4 add t3,t3,1 beq t3,$a0,mulc_nextl j mulc_loop3 mulc next1: calculate the offset of element at [i] [j) mul t2,t0,$a0 add t2,t2,$ tl sll t2,t2,2 add $t3,t2,a3 $t7, (t3) multiply with storage size C[i] [i]sum or A[i] [k] *B [k] [il SW # i=i+ 1 add t0,t0,1 beq st0,$a0, mulc next2 j mulc loop2 add tl,tl,l beq tl,a0, addover # if i-4 and j-4 j mulc loopl if j-4, exit the inner loop mulc next2: #j-j+1 ,exit the outer loop #Return to main program addover: jr ra

#Procedure to print the matrix of double precission values printma trix : li to,0 # i-0 # st2- address of the matrix move t2, a0 oloop: li tl,0 #j-0 iloop lw a0, (t2) li v0,1 syscall add t2,t2,4 add t0,t0,1 add tl,tl,l beq tl,4,print_next la a0,space li v0,4 syscall j iloop la $a0,newline #print the number # cro to next element # i-i+ 1 # j-j+1 if j-4, exit the inner loop print spa ce go to label iloop print new line print next: li v0,4 syscall beq to,16,printingover joloop if i-16, exit the outer loop printingover: print new line la a0,newline li v0,4 syscall jr ra #Return to main procedure

Sample output:

Mars Messages Run I/O A= 2 1 9 2 7 9 10 10 3 4 4 4 2 5 4 4 B 8 7 1 2 2 78 6 7 5 6 8 9 489 Using row major, C-A+B = 10 8 10 4 Clear 9 16 18 16 10 9 10 12 11 9 12 13 Using column major, C-A+B = 10 8 10 4 9 16 18 16 10 9 10 12 11 9 12 13 Using row major, C-AxB= 99 74 80 100 234 202 219 238 96 85 91 98 90 85 98 102 Using column major, C -AxB 99 74 80 100 234 202 219 238 96 85 91 98 90 85 98 102 program is finished running

Code to copy:

######################################## rowcol_major.asm ##################################

.data

A:            .word 2,1,9,2

                .word 7,9,10,10

                .word 3,4,4,4

                .word 2,5,4,4

B:            .word 8,7,1,2

                .word 2,7,8,6

                .word 7,5,6,8

                .word 9,4,8,9

C:            .word 0:4

                .word 0:4

                .word 0:4

                .word 0:4

message1:.asciiz "A=\n"

message2:.asciiz "B=\n"

message3:.asciiz "Using row major, C=A+B=\n"

message4:.asciiz "Using column major, C=A+B=\n"

message5:.asciiz "Using row major, C=AxB=\n"

message6:.asciiz "Using column major, C=AxB=\n"

space: .asciiz " "

newline: .asciiz "\n"

.text

main:     li $v0,4

                la $a0,message1

                syscall

                #Print matrix A

                la $a0,A                                # Pass base address of A to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix

                li $v0,4

                la $a0,message2

                syscall

                #Print matrix B

                la $a0,B                                # pass address of the matrix B to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix   

                # Test add_Rowmajor

                #Add A and B using row major and save the result in C

                li $a0,4                                  # Pass row size(and column size) to mul_Rowmajor

                la $a1,A                                # Pass base address of A

                la $a2,B                                # Pass base address of B

                la $a3,C                                # Pass base address of C

                jal add_Rowmajor                           # Call add_Rowmajor

                #Print resultant matrix C

                li $v0,4

                la $a0,message3

                syscall

                la $a0,C                                # pass address of the matrix C to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix                    # Call printmatrix

                # Test add_Colmajor

                #Add A and B using column major and save the result in C

                li $a0,4                                  # Pass row size(and column size) to mul_Rowmajor

                la $a1,A                                # Pass base address of A

                la $a2,B                                # Pass base address of B

                la $a3,C                                # Pass base address of C

                jal add_Colmajor                              # Call add_Colmajor

                #Print resultant matrix C

                li $v0,4

                la $a0,message4

                syscall

                la $a0,C                                # pass address of the matrix C to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix                    # Call printmatrix

                # Test mul_Rowmajor

                # Multiply A and B using row major and save the result in C

                li $a0,4                                  # Pass row size(and column size) to mul_Rowmajor

                la $a1,A                                # Pass base address of A

                la $a2,B                                # Pass base address of B

                la $a3,C                                # Pass base address of C

                jal mul_Rowmajor                           # Call mul_Rowmajor

                #Print resultant matrix C

                li $v0,4

                la $a0,message5

                syscall

                la $a0,C                                # pass address of the matrix C to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix                    # Call printmatrix

                # Test mul_Colmajor

                # Multiply A and B using column major and save the result in C

                li $a0,4                                  # Pass row size(and column size) to mul_Rowmajor

                la $a1,A                                # Pass base address of A

                la $a2,B                                # Pass base address of B

                la $a3,C                                # Pass base address of C

                jal mul_Colmajor                              # Call mul_Colmajor

                #Print resultant matrix C

                li $v0,4

                la $a0,message6

                syscall

                la $a0,C                                # pass address of the matrix C to printmatrix

                li $a1,4                                  # Pass row size

                li $a2,4                                  # Pass column size

                jal printmatrix                    # Call printmatrix

                #exit

                li $v0, 10                              # End the program

                syscall

#Procedure to add two matrices using row major

add_Rowmajor:                               

                                li $t0,0                   # i=0

addr_loop1:       li $t1,0                   # j=0

addr_loop2:       mul $t2,$t0,$a0 # calculate the offset of element at [i][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2

                               

                                add $t3,$t2,$a1

                                lw $t4,($t3)         # $t4=A[i][j]

                                add $t3,$t2,$a2

                                lw $t5,($t3)         # $t5=B[i][j]

                               

                                add $t4,$t4,$t5 # $t4=A[i][j]+B[i][j]

                               

                                add $t3,$t2,$a3

                                sw $t4,($t3)       # C[i][j]=A[i][j]+B[i][j]

                                               

                                add $t1,$t1,1      # j=j+1

                                beq $t1,4,addr_next       # if j=4, exit the inner loop          

                                j addr_loop2

addr_next:         add $t0,$t0,1      # i=i+1

                                beq $t0,4,return_add_Rowmajor # if i=4 and j=4 , exit the outer loop

                                j addr_loop1

               

return_add_Rowmajor: jr $ra                                      #Return to main program

#Procedure to add two matrices using column major

add_Colmajor:                                 

                                li $t1,0                   # j=0

addc_loop1:       li $t0,0                   # i=0

addc_loop2:       mul $t2,$t0,$a0 # calculate the offset of element at [i][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2

                               

                                add $t3,$t2,$a1

                                lw $t4,($t3)         # $t4=A[i][j]

                                add $t3,$t2,$a2

                                lw $t5,($t3)         # $t5=B[i][j]

                               

                                add $t4,$t4,$t5 # $t4=A[i][j]+B[i][j]

                               

                                add $t3,$t2,$a3

                                sw $t4,($t3)       # C[i][j]=A[i][j]+B[i][j]

                                               

                                add $t0,$t0,1      # i=i+1

                                beq $t0,4,addc_next # if j=4, exit the inner loop

                                j addc_loop2

addc_next:         add $t1,$t1,1      # j=j+1

                                beq $t1,4,return_add_Colmajor # if i=4 and j=4 , exit the outer loop

                                j addc_loop1

return_add_Colmajor: jr $ra                                        #Return to main program

#Procedure to multiply two matrices using row major

mul_Rowmajor:                               

                                li $t0,0                   # i=0

mulr_loop1:       li $t1,0                   # j=0

mulr_loop2:       li $t3,0                   # k=0

                                li $t7,0                   # sum=0

mulr_loop3:       mul $t2,$t0,$a0 # calculate the offset of element A[i][k]

                                add $t2,$t2,$t3

                                sll $t2,$t2,2         # multiply with storage size

                                add $t4,$t2,$a1

                                lw $t4,($t4)

                               

                                mul $t2,$t3,$a0 # calculate the offset of element at B[k][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2         # multiply with storage size

                                add $t5,$t2,$a2

                                lw $t5,($t5)

                               

                                mul $t4,$t4,$t5

                                add $t7,$t7,$t4

                                add $t3,$t3,1

                                beq $t3,$a0,mulr_next1

                                j mulr_loop3

mulr_next1:

                                mul $t2,$t0,$a0 # calculate the offset of element at [i][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2         # multiply with storage size

                                add $t3,$t2,$a3

                                sw $t7,($t3)       # C[i][j]=sum or A[i][k]*B[k][j]

                                               

                                add $t1,$t1,1      # j=j+1

                                beq $t1,$a0,mulr_next2                # if j=4, exit the inner loop          

                                j mulr_loop2

mulr_next2:       add $t0,$t0,1      # i=i+1

                                beq $t0,$a0,return_mul_Rowmajor # if i=4 and j=4 , exit the outer loop

                                j mulr_loop1

               

return_mul_Rowmajor: jr $ra                                     #Return to main program

#Procedure to add two matrices using row major

mul_Colmajor:                                 

                                li $t1,0                   # j=0

mulc_loop1:       li $t0,0                   # i=0

mulc_loop2:                      

                                li $t3,0                   # k=0

                                li $t7,0                   # sum=0

mulc_loop3:       mul $t2,$t0,$a0 # calculate the offset of element A[i][k]

                                add $t2,$t2,$t3

                                sll $t2,$t2,2         # multiply with storage size

                                add $t4,$t2,$a1

                                lw $t4,($t4)

                               

                                mul $t2,$t3,$a0 # calculate the offset of element at B[k][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2         # multiply with storage size

                                add $t5,$t2,$a2

                                lw $t5,($t5)

                               

                                mul $t4,$t4,$t5

                                add $t7,$t7,$t4

                                add $t3,$t3,1

                                beq $t3,$a0,mulc_next1

                                j mulc_loop3

mulc_next1:

                                mul $t2,$t0,$a0 # calculate the offset of element at [i][j]

                                add $t2,$t2,$t1

                                sll $t2,$t2,2         # multiply with storage size

                                add $t3,$t2,$a3

                                sw $t7,($t3)       # C[i][j]=sum or A[i][k]*B[k][j]

                                               

                                add $t0,$t0,1      # i=i+1

                                beq $t0,$a0,mulc_next2               # if j=4, exit the inner loop          

                                j mulc_loop2

mulc_next2:       add $t1,$t1,1      # j=j+1

                                beq $t1,$a0,addover # if i=4 and j=4 , exit the outer loop

                                j mulc_loop1

               

addover: jr $ra                                   #Return to main program

#Procedure to print the matrix of double precission values

printmatrix :                      

                                li $t0,0                   # i=0

                                                               

                                move $t2,$a0     # $t2=address of the matrix

oloop:

                                li $t1,0                   # j=0

iloop:

                                lw $a0, ($t2)      

                                li $v0,1

                                syscall                   # print the number

                                add $t2,$t2,4      # go to next element

                                add $t0,$t0,1      # i=i+1

                                add $t1,$t1,1      # j=j+1

                                beq $t1,4,print_next      # if j=4, exit the inner loop

                                la $a0,space       # print space

                                li $v0,4

                                syscall

                                j iloop                    # go to label iloop

print_next:         la $a0,newline   # print new line

                                li $v0,4                 

                                syscall  

                                beq $t0,16,printingover # if i=16, exit the outer loop

                                j oloop

printingover:      la $a0,newline   # print new line

                                li $v0,4

                                syscall

                                jr $ra                      #Return to main procedure

############################################################################################