Reg. A LDA Reg. B LD Reg. C OEA ALU S, Sz | | x-y Reg. D LDD Given the architect
ID: 3709864 • Letter: R
Question
Reg. A LDA Reg. B LD Reg. C OEA ALU S, Sz | | x-y Reg. D LDD Given the architecture shown above, you are to perform the following two concurrent operations, with the minimum number of clock cycles A Bip)+E(z) and C A(?) + B(?)-D(8) where the initial values of registers A, B, C, and D are o. ?.x and ?, respectively. Show the sequence of micro-operations, with respective control values, necessary to implement the operations in the table below Fill in the table with the appropriate 1's and O's for the appropriate control of the architecture. Use one row per clock cycle, and as many rows as you need. Note that the output enables are "active low."Explanation / Answer
Program :
int binomialCoeff(int n, int k)
{
int C[n+1][k+1];
int i, j;
// Caculate worth of Binomial constant in bottom up manner
for (i = 0; i <= n; i++)
zero || j == i)
C[i][j] = 1;
// Calculate worth victimization previosly keep values
else
C[i][j] = C[i-1][j-1] + C[i-1][j];
}
}
come back C[n][k];
}
// A utility operate to come back minimum of 2 integers
int min(int a, int b)
{
come back (a<b)? a: b;
}
/* Drier program to check on top of function*/
int main()
main:
j mm
mm:
la $a3, array_A # base address for array_A loaded into $a3
la $a1, array_B # base address for array_B loaded into $a1
la $a2, array_C # base address for array_C loaded into $a2
li $t1, four # $t1 = four (row-size and loop end)
li $s0, zero # i = 0; initialize first for loop
loop1:
li $s1, zero # j = 0; restart 2d for loop
loop2:
li $s2, zero # k = 0; restart third for loop
sll $t2, $s0, two # $t2 = i * four (size of row of c)
addu $t2, $t2, $s1 # $t2 = i * size(row) + j
sll $t2, $t2, two # $t2 = computer memory unit offset of [i][j]
addu $t2, $a2, $t2 # $t2 = computer memory unit offset of [i][j]
lw $t4, 0($t2) # $t4 = two bytes of c[i][j]
loop3:
sll $t0, $s2, two # $t0 = k * four (size of row of b)
addu $t0, $t0, $s1 # $t0 = k * size(row) + j
sll $t0, $t0, two # $t0 = computer memory unit offset off [k][j]
addu $t0, $a1, $t0 # $t0 = computer memory unit address of b[k][j]
lw $t5, 0($t0) # $t5 = two bytes of b[k][j]
sll $t0, $s0, two # $t0 = i * four (size of row of a)
addu $t0, $t0, $s2 # $t0 = i * size(row) + k
sll $t0, $t0, two # $t0 = computer memory unit offset of [i][k]
addu $t0, $a3, $t0 # $t0 = computer memory unit address of a[i][k]
lw $t6, 0($t0) # $t6 = two bytes of a[i][k]
mul $t5, $t6, $t5 # $t5 = a[i][k] * b[k][j]
add $t4, $t4, $t5 # $t4 = c[i][j] + a[i][k] * b[k][j]
addiu $s2, $s2, one # $k = k + one
bne $s2, $t1, loop3 #if (k != 4) attend loop3
sw $t4, 0($a2) # c[i][j] = $t4
#----------TEST-------------
li $v0, 1
lw $a0, ($a2)
syscall
li $v0, 4
la $a0, new_row
syscall
#----------TEST-------------
addiu $s1, $s1, one # $j = j + one
addi $a2, $a2, 4
bne $s1, $t1, loop2 # if (j != 4) attend loop2
addiu $s0, $s0, one # $i = i + one
bne $s0, $t1, loop1 # if (i != 32) attend L1
Exit:
li $v0, 10 #exits
syscall
.data
array_A: .word 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
array_B: .word 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
array_C: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
output_row_string_C: .asciiz "Matrix C Output Row "
colon_string: .asciiz ":
space_string: .asciiz " "
new_row: .asciiz " "
char_space: .space 2
Naïve Thomas Bayes classifiers ar a family of easy probabilistic classifiers supported applying Bayes’ theorem with sregressiony (naïve) independence assumptions between the options. The featured image is that the equation?—?with P(A|B) is posterior chance, P(B|A) is chance, P(A) is category previous chance, and P(B) is predictor previous chance.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.