Roll Pair Of Dice And Calculate The Percentage For Each Value After N Trials Using MARS Mips Assembly Assignment Solution

Instructions

Objective

Write a program in assembly language to roll pair of dice and calculate the percentage for each value after n trials using MARS Mips assembly.

Requirements and Specifications

Write a simple assembly language function to simulate the rolling of two dice. The provided main calls the following functions:

• Write a value returning MIPS function, getInput(), that will read a number between 1 and 100,000. Note, A MIPS function returns its integer result in $v0.
• Write a value returning MIPS function, random(), to generate a random number using a lagged Fibonacci generator1.
• Write a void MIPS function, throwDice(), to simulate the rolling of two dice n times. Each die can show an integer value from 1 to 6, so the sum of the values would vary from 2 to 12. The results should be stored in a two-dimension array. The first roll represents the row and the second roll represents the column. This function will call the random() function.
• Write a MIPS assignment function, results(), to calculate sums, percentages, and display the twodimensional matrix showing the results. The numbers should be printed in a twodimensional format (see example output). All numbers in the table must be right justified (i.e., lined up on right side). Print the eleven possible different totals followed by the percent each combination occurred. For the final percentages, the sums should be computed as integers, then converted to float (single precision), divided by the roll count (also converted to single precision), and multiplied by 100.00. Due to the required formatting, this is likely the most difficult function.

Array Implementation: In assembly, multidimensional arrays are implemented as a large single dimension array. The formula for calculating two-dimensional array indexing is: addr(row,col) = baseAddr + (rowIndex * colSize + colIndex) * data_size

Screenshots of output

Source Code

# Name: # NSHE ID: # Section: # Assignment: #4 # Description: MIPS assembly language program to simulate the rolling of two dice. # CS 218 # MIPS Assignment #4 # MIPS assembly language program to simulate the rolling of two dice. ########################################################### # data segment .data hdr: .ascii "MIPS Assignment #4 \n" .asciiz "Program to Simulate Rolling Two Dice. \n\n" # ----- # Dice Results Matrix dice: .word 0, 0, 0, 0, 0, 0 .word 0, 0, 0, 0, 0, 0 .word 0, 0, 0, 0, 0, 0 .word 0, 0, 0, 0, 0, 0 .word 0, 0, 0, 0, 0, 0 .word 0, 0, 0, 0, 0, 0 rolls: .word 0 # ----- # Local variables for GetInput function. MIN = 1 MAX = 100000 rd_hdr: .asciiz "\nDice Rolls Simulation Input Routine\n\n" rd_rolls: .asciiz "Enter Number of Dice Rolls to Simulate: " er_rolls: .ascii "\nError, rolls must be beween 1 and 100000\n" .asciiz "Please re-enter\n\n" # ----- # Local variables for random function. s_tbl: .word 47174, 64426, 21990, 28426, 63878 .word 52330, 17190, 29642, 53958, 50474 .word 18535, 8330, 17414, 58858, 26022 .word 30026, 0 jptr: .word 16 kptr: .word 4 ltmp: .word 0 # ----- # Local variables for Result procedure. r_hdr: .ascii "\n\n************************************\n\n" .asciiz "Rolls: " r_top: .asciiz " ------- ------- ------- ------- ------- -------\n" new_ln: .asciiz "\n" bar: .asciiz " |" blnks1: .asciiz " " blnks2: .asciiz " " blnks3: .asciiz " " blnks4: .asciiz " " blnks5: .asciiz " " blnks6: .asciiz " " colon: .asciiz ": " colon2: .asciiz ": " pctHdr: .asciiz "\n\nPercentages:\n" hundred: .float 100.0 sums: .word 0 # 2s .word 0 # 3s .word 0 # 4s .word 0 # 5s .word 0 # 6s .word 0 # 7s .word 0 # 8s .word 0 # 9s .word 0 # 10s .word 0 # 11s .word 0 # 12s ########################################################### # text/code segment .text .globl main .ent main main: # ----- # Display main program header. la $a0, hdr li $v0, 4 syscall # print header # ----- # Get user input. jal getInput sw $v0, rolls # ----- # Throw the dice 'rolls' times, track results. la $a0, dice lw $a1, rolls jal throwDice # ----- # Calculate totals, compute percentages, and display results la $a0, dice lw $a1, rolls jal results # ----- # Done, terminate program. li $v0, 10 syscall .end main ###################################################### # Procedure to read a number between between 1 and 100,000. # Returns its result in $v0. # YOUR CODE GOES HERE .globl getInput .ent getInput getInput: la $a0, rd_hdr # show input title li $v0, 4 syscall la $a0, rd_rolls # prompt user to enter a number li $v0, 4 syscall li $v0, 5 # read number syscall blt $v0, MIN, badRolls # if < MIN, it's a bad number ble $v0, MAX, goodRolls # if <= MAX, it's a good number badRolls: la $a0, er_rolls # print error string li $v0, 4 syscall j getInput # read input again goodRolls: jr $ra # return input value .end getInput ###################################################### # Function to generate pseudo random numbers using # the lagged Fibonacci generator. # Since function, returns result in $v0. # Algorithm: # itmp = s_table(jptr) + s_table(kptr) # s_table(jptr) = itmp mod 2^16 # jptr = jptr - 1 # kptr = kptr - 1 # if ( jptr < 0 ) jptr = 16 # if ( kptr < 0 ) kptr = 16 # rand_dice = ( itmp / 100 ) mod 6 # ----- # Arguments: # none # Returns: # $v0 # YOUR CODE GOES HERE .globl random .ent random random: lw $t0, jptr # load current j position sll $t1, $t0, 2 # j*4 lw $t2, s_tbl($t1) # load s_table(jptr) lw $t3, kptr # load current k position sll $t4, $t3, 2 # k*4 lw $t5, s_tbl($t4) # load s_table(kptr) add $t2, $t2, $t5 # itmp = s_table(jptr) + s_table(kptr) andi $t6, $t2, 0xFFFF # itmp mod 2^16 sw $t6, s_tbl($t1) # s_table(jptr) = itmp mod 2^16 addi $t0, $t0, -1 # jptr = jptr - 1 addi $t3, $t3, -1 # kptr = kptr - 1 bgez $t0, ifk # if (jptr < 0) li $t0, 16 # jptr = 16 ifk: bgez $t3, rnd # if (kptr < 0) li $t3, 16 # kptr = 16 rnd: sw $t0, jptr # save jptr sw $t3, kptr # save kptr div $t2, $t2, 100 # itmp/100 li $t0, 6 # divide by 6 div $t2, $t0 # itmp/100 / 6 mfhi $v0 # return ( itmp / 100 ) mod 6 jr $ra .end random ###################################################### # Procedure to simulate the rolling of two dice n times. # Each die can show an integer value from 1 to 6, so the sum of # the values will vary from 2 to 12. # The results are stored in a two-dimension array. # Calls the Random() function. # ----- # Formula for multiple dimension array indexing: # addr(row,col) = base_address + (rowindex * col_size + colindex) * element_size # ----- # Arguments # $a0 - address of dice two-dimension array # $a1 - number of 'rolls' # YOUR CODE GOES HERE .globl throwDice .ent throwDice throwDice: addi $sp, $sp, -8 # allocate space in stack to save registers sw $ra, 0($sp) # save return address sw $s0, 4($sp) # save $s0 throwLoop: jal random # throw first dice move $s0, $v0 # save generated number (row) jal random # throw second dice, $v0 is column mul $s0, $s0, 6 # multiply rowindex* col_size add $s0, $s0, $v0 # add rowindex* col_size + colindex sll $s0, $s0, 2 # multiply by 4 (element size) add $s0, $s0, $a0 # add base_address to get addr(row,col) lw $t0, 0($s0) # load old count addi $t0, $t0, 1 # increment count sw $t0, 0($s0) # update count addi $a1, $a1, -1 # decrement number of rolls bnez $a1, throwLoop # if not zero, throw another one lw $ra, 0($sp) # load return address lw $s0, 4($sp) # load $s0 addi $sp, $sp, 8 # remove allocated space from stack jr $ra .end throwDice ###################################################### # Procedure to calculate sums, percentages, and display the # two-dimensional matrix showing the results. # Arguments: # $a0 - starting address of dice matrix # $a1 - number of rolls .globl results .ent results results: # YOUR CODE GOES HERE move $t0, $a0 # save matrix address move $t1, $a1 # save number of rolls la $a0, r_hdr # display header li $v0, 4 syscall move $a0, $t1 # print number of rolls li $v0, 1 syscall la $a0, new_ln # display newline li $v0, 4 syscall syscall # double newline la $a0, r_top # display top line li $v0, 4 syscall mtc1 $t1, $f1 # convert number of rolls cvt.s.w $f1, $f1 # convert to float li $t1, 0 # start in row 0 dispRow: la $a0, bar # display initial column bar li $v0, 4 syscall li $t2, 0 # start in column 0 dispCol: mul $t3, $t1, 6 # multiply rowindex* col_size add $t3, $t3, $t2 # add rowindex* col_size + colindex sll $t3, $t3, 2 # multiply by 4 (element size) add $t3, $t3, $t0 # add base_address to get addr(row,col) lw $t3, 0($t3) # load matrix(row,col) bgt $t3, 9999, disp1 # if 5 digits, display 1 space bgt $t3, 999, disp2 # if 4 digits, display 2 spaces bgt $t3, 99, disp3 # if 3 digits, display 3 spaces bgt $t3, 9, disp4 # if 2 digits, display 4 spaces j disp5 # else (1 digit) display 5 spaces disp1: la $a0, blnks2 j dispSpaces disp2: la $a0, blnks3 j dispSpaces disp3: la $a0, blnks4 j dispSpaces disp4: la $a0, blnks5 j dispSpaces disp5: la $a0, blnks6 dispSpaces: li $v0, 4 syscall move $a0, $t3 # display number li $v0, 1 syscall la $a0, bar # display ending column bar li $v0, 4 syscall add $t4, $t1, $t2 # add row + column to get total dice roll sll $t4, $t4, 2 # multiply by element size lw $t5, sums($t4) # load old sum value add $t5, $t5, $t3 # add count sw $t5, sums($t4) # save new sum value addi $t2, $t2, 1 # increment column blt $t2, 6, dispCol # repeat while col < 6 la $a0, new_ln # display newline li $v0, 4 syscall addi $t1, $t1, 1 # increment row blt $t1, 6, dispRow # repeat while row < 6 la $a0, r_top # display bottom line li $v0, 4 syscall la $a0, new_ln # display newline li $v0, 4 syscall la $a0, pctHdr # print percentage string li $v0, 4 syscall l.s $f2, hundred # load 100 for calculations li $t0, 0 # start in first percentage percLoop: la $a0, blnks5 # print initial spaces li $v0, 4 syscall addi $a0, $t0, 2 # get roll number from index li $v0, 1 # print it syscall la $a0, colon # load colon string addres blt $t0, 8, printColon # if roll < 8, print colon la $a0, colon2 # else use colon2 printColon: li $v0, 4 # print the colon syscall la $a0, blnks1 # print a space li $v0, 4 syscall sll $t1, $t0, 2 # multiply index by element size lw $t1, sums($t1) # load sums[i] mtc1 $t1, $f0 # load to coprocessor register cvt.s.w $f0, $f0 # convert to float div.s $f12, $f0, $f1 # divide num rolls/ total rolls mul.s $f12, $f12, $f2 # multiply by 100 li $v0, 2 # print the float result syscall la $a0, new_ln # display newline li $v0, 4 syscall addi $t0, $t0, 1 # increment index blt $t0, 11, percLoop # repeat while index < 11 jr $ra .end results ######################################################