For our $3\backslash$times $3$ case, the circuit computes:

Y$11=$ W$11\backslash$times X$11+$ W$12\backslash$times X$12+$ W$13\backslash$times X$13$

Y$12=$ W$21\backslash$times X$11+$ W$22\backslash$times X$12+$ W$23\backslash$times X$13$

Y$13=$ W$31\backslash$times X$11+$ W$32\backslash$times X$12+$ W$33\backslash$times X$13$

Y$21=$ W$11\backslash$times X$21+$ W$12\backslash$times X$22+$ W$13\backslash$times X$23$

Y$22=$ W$21\backslash$times X$21+$ W$22\backslash$times X$22+$ W$23\backslash$times X$23$

Y$23=$ W$31\backslash$times X$21+$ W$32\backslash$times X$22+$ W$33\backslash$times X$23$

Y$31=$ W$11\backslash$times X$31+$ W$12\backslash$times X$32+$ W$13\backslash$times X$33$

Y$32=$ W$21\backslash$times X$31+$ W$22\backslash$times X$32+$ W$23\backslash$times X$33$

Y$33=$ W$31\backslash$times X$31+$ W$32\backslash$times X$32+$ W$33\backslash$times X$33$

Write MIPS code to implement the above $3\backslash$times $3$ multiplier. All of the W and X

values need to be loaded from memory, and all of the resulting Y values are stored into memory. You can use registers for holding partial products $($and of course the registers are used when loading values to and from memory$).$ This is doing floating point adds and multiplies, so try to design your code to minimize stalls. How many cycles does it take to perform this operation?

I have already written the mips code for this question. Can you please evaluate to see if it is okay? Also can you answer me the question of "How many cycles does it take to perform this operation?"

$.$data

dimensions: $.$word $3$ # Square matrix length $-$ row width, column height kept same for simplicity.

matrix$\_$size: $.$word $9$ # Total size $-3$ x $3$

weights: $.$float $1,2,3,4,5,6,7,8,9$ # Fill weights with arbitrary values. from left to right $-$ W$11,$ W$12,$ W$13,$ W$21,$ W$22,$ W$23,$ W$31,$ W$32,$ W$33$

X: $.$float $10,11,12,13,14,15,16,17,18$ # Fill memory X with arbitrary values. from left to right $-$ X$11,$ X$12,$ X$13,$ X$21,$ X$22,$ X$23,$ X$31,$ X$32,$ X$33$

Y: $.$float $0,0,0,0,0,0,0,0,0$ # Initialize result array with $0$ values $-$ Y$11,$ Y$12,$ Y$13,$ Y$21,$ Y$22,$ Y$23,$ Y$31,$ Y$32,$ Y$33$

offset: $.$word $4$ # Single precision floating offset value

new$\_$line: $.$asciiz $"$

$"$ # New line constant

zero: $.$word $0$ # Zero value constant

siva: $.$asciiz "Program designed and executed by Siva Charan Mallena, Bronco Id: $016568110"$

$.$text

$.$globl main

main:

la $s$0,$ X #load address of X variable

la $s$1,$ weights #load address of weights variable

lw $s$2,$ dimensions #dimension size into register

la $s$3,$ Y #load address of resulting matrix

lw $s$4,$ offset #load offset into a register

lw $s$5,$ matrix$\_$size #total matrix size into register

li $s$7,0$ #print loop counter

li $t$1,0$ #row loop counter

li $t$2,0$ #col loop counter

li $t$3,0$ #mult$\_$add$\_$loop counter

lwc$1$ $f$10,$ zero #load zero into temp register for zeroing Y value later

j row$\_$loop #start! jump to matrix multiplication loop

li $v$0,10$ #exit out! this is not necessary i guess, since there is an exit method which will be called by row$\_$loop

syscall

row$\_$loop: # i

bge $t$1,$ $s$2,$ reset$\_$Y$\_$address$\_$and$\_$print # break out to printing final result $($ Y $)$

j col$\_$loop # jump to inner loop

col$\_$loop$\_$ret: # return location for col$\_$loop

addi $t$1,$ $t$1,1$ # increment row loop counter

li $t$2,0$ # reset col loop counter

j row$\_$loop # looop

col$\_$loop: # j

bge $t$2,$ $s$2,$ col$\_$loop$\_$ret # break out to row$\_$loop upon completion

lwc$1$ $f$4,($$s$3)$ # load current Y location value into $f$4$

j mult$\_$add$\_$loop # jump to multiplication and add loop

mult$\_$add$\_$loop$\_$ret: # return locatioin for mult$\_$add$\_$loop

s$.$s $f$4,($$s$3)$ # Save $f$4$ back to its current pointed address

add $s$3,$ $s$3,$ $s$4$ # increment Y$\text{'}$s location for the next Y value

addi $t$2,$ $t$2,1$ # increment col$\_$loop counter

li $t$3,0$ # reset mult$\_$add$\_$loop counter

mov.s $f$4,$ $f$10$ # reset $f$4$ value to $0$

j col$\_$loop # loooop

mult$\_$add$\_$loop: # k

bge $t$3,$ $s$2,$ mult$\_$add$\_$loop$\_$ret # break out to col$\_$loop

# W offset $=($j $*3)+$ k

mul $t$4,$ $t$2,$ $s$2$ # j $*3$

add $t$4,$ $t$4,$ $t$3$ # j $*3+$ K;

mul $t$4,$ $t$4,$ $s$4$ # multiply offset with length of word$/$single precision. t$4$ is absolute offset. which means address of w must be pointed to first element then $t$4$ must be added.

add $t$4,$ $s$1,$ $t$4$ # get address of value to be fetched for W

lwc$1$ $f$1,($$t$4)$ # load actual value to FP register

#X offset $=($i $*3)+$ k

mul $t$5,$ $t$1,$ $s$2$ # i $*3$

add $t$5,$ $t$5,$ $t$3$ # i $*3+$ k; t$5$ is absolute offset. which means address of w must be pointed to first element then $t$5$ must be added.

mul $t$5,$ $t$5,$ $s$4$ # multiply offset with length of word$/$single precision

add $t$5,$ $s$0,$ $t$5$ # get address of value to be fetched for W

lwc$1$ $f$2,($$t$5)$ # load actual value to FP register

mul.s $f$3,$ $f$2,$ $f$1$ # both W and X values are loaded. now multiply

add.s $f$4,$ $f$4,$ $f$3$ # Y $=$ Y$+($W$*$X$)$

addi $t$3,$ $t$3,1$ # increment mult$\_$add$\_$loop counter

j mult$\_$add$\_$loop # loooop

reset$\_$Y$\_$address$\_$and$\_$print:

la $s$3,$ Y

la $a$0,$ siva # load my name

li $v$0,4$ # load print text command to $v$0$

syscall

j print$\_$Y

print$\_$Y:

bge $s$7,$ $s$5,$ end$\_$program # break out to exit

li $v$0,2$ # print from $f