More Better Assembly CSCI 136 Lab 4

Soapbox Philosophy SAD TRUTH: THE TRIAL AND ERROR METHOD OF PROGRAMMING IS A WASTE OF TIME. Plan your program before you sit down in front of the computer. What are the parameters? The algorithm? What registers will I use for what? What loops do I have? What do I need to save on the stack?

Can we write this a different way? move $a2,$s1 #$a2 = middle addi $a2,$a2,1 #$a2 = middle+1

How about this? add $a2, $t0, $0 # a2 = middle addi $a2, 1 # a2 = middle + 1

Know You Instructions! Or at least look them up... ori $t1, $0, 1# set $t1 to 1 srl $a3, $t0, $t1# temp / 2

sub $t1, $a3, $a2#middle = high-low div $t1, $t1, 2 #middle= (high-low)/2 add $t1, $t1, $a2 #$t1 =((high-low)/2)+ low #recursive call with ourArray, tempArray, #low, middle need to save high, low, middle- #push onto stack sub $sp, $sp,4#adjust stack pointer sw $a3, 0($sp)#push high onto stack lw $a3, 0($t1)# last parameter = middle

No need to clear registers! xor $t0, $t0, $t0 xor $t1, $t1, $t1 add $t0, $a0, $t4 #ourArray[upperIndex] add $t1, $a1, $t7 #tempArray[newIndex] Sadly, this person cleared a very important register on accident. Otherwise their program would have actually worked. :(

DeMorgan is Your Friend! NOT (A AND B) = (NOT A) OR (NOT B) while(lowerIndex<=middle && upperIndex<=high) bgt lowerIndex,middle,whileDone bgt upperIndex,high,whileDone This is just an example… In many cases DeMorgan’s Law will make your life much, much easier.

Move the Stack Pointer once? addi $sp, -4 # move sp sw $a2, 0($sp) # store low addi $sp, -4 # move sp sw $a3, 0($sp) # store high addi $sp, -4 # move sp sw $t0, 0($sp) # store middle

Move the Stack Pointer once! addi $sp, -4 # move sp sw $a2, 0($sp) # store low addi $sp, -4 # move sp sw $a3, 0($sp) # store high addi $sp, -4 # move sp sw $t0, 0($sp) # store middle addi $sp, $sp, -12 #move sp sw $a2,8($sp) #store low sw $a3,4($sp) #store high sw $t0,0($sp) #store middle

Keep your register assignments! msfor1: sle $t0, $t1, $a3# count <= high beqz $t0, msfor1End #Set the address of ourArray[count] add $t2, $a0, $t4 #Set the address of tempArray[newIndex] add $t3, $a1, $t7 lw $t4, 0($t2) # get ourArray[count] sw $t4, 0($t3) # tempArray[newIndex] =ourArray[count] addi $s1, $s1, 1 # move newIndex to the next element addi $t7, $t7, 4 addi $t1, $t1, 1# move count to the next element #move the address of the next element up one word addi $t4, $t4, 4 j msfor1# continue for loop msfor1End:

Uh. This isn’t going to work! msfor1: sle $t0, $t1, $a3# count <= high beqz $t0, msfor1End #Set the address of ourArray[count] add $t2, $a0, $t4 #Set the address of tempArray[newIndex] add $t3, $a1, $t7 lw $t4, 0($t2) # get ourArray[count] sw $t4, 0($t3) # tempArray[newIndex] =ourArray[count] addi $s1, $s1, 1 # move newIndex to the next element addi $t7, $t7, 4 addi $t1, $t1, 1# move count to the next element #move the address of the next element up one word addi $t4, $t4, 4 j msfor1# continue for loop msfor1End:

What's wrong with this? Whileloop: blt$t0, $t1, exitwhileloop blt$a3, $t3, exitwhileloop sll$t7, $t1, 2#multiply by 4 add$t7, $t7, $a0 lw$t5, ($t7)#load lower value sll$t7, $t3, 2 add$t7, $a0, $t7 lw $t5, ($t7)#load upper value

Stack: For all paths through your code What goes on… Must come off! MergeSort: sub $sp, $sp,4 #|push sw $ra, ($sp) #|$a2 and $a3 beq$a2, $a3, exit exit: lw$a2, 8($sp)#restore $a2 lw$ra, 12($sp) #retrieve return instruction from stack addi $sp, $sp, 16 jr$ra

MergeSort: sub $sp,$sp,16 sw $s0, 0($sp) # low sw $s1, 4($sp) # mid sw $s2, 8($sp) # high sw $s3, 12($ra) # ra beq $a2,$a3,Finish Finish: lw $s0, 0($sp) # low lw $s1, 4($sp) # mid lw $s2, 8($sp) # high lw $s3, 12($ra) # ra addi $sp,$sp, 16 lw $s1,0($sp) lw $ra,4($sp) addi $sp,$sp,8 jr $ra Stack: For all paths through your code Leave It Like You Found It! When this function exits... the stack pointer is 8 bytes above where it started the function at... TRANSLATION: THIS ISN'T GOING TO WORK

MergeSort: sub $sp,$sp,16 sw $s0, 0($sp) # low sw $s1, 4($sp) # mid sw $s2, 8($sp) # high sw $s3, 12($ra) # ra beq $a2,$a3,Finish Finish: lw $s0, 0($sp) # low lw $s1, 4($sp) # mid lw $s2, 8($sp) # high lw $s3, 12($ra) # ra addi $sp,$sp, 16 lw $s1,0($sp) lw $ra,4($sp) addi $sp,$sp,8 jr $ra What do these lines do?

Code Efficiency #moves pointer to lower index add $t0,$a0,$zero add $t1,$s4,$s4 # t1 = lowerindex *2 add $t1,$t1,$t1 # t1 = lowerindex *4 add $t2,$t0,$t1 # t2 = adddress ourarray[lowerIndex] Write this in 2 instructions.

If you need it later: You should probably save it! MergeSort:... beq$a2, $a3, exit #base case sub$t0, $a3, $a2 #(high-low) srl $t0,$t0,1 #(high-low)/2 add$t0, $t0, $a2 # + low move $a3, $t0 How in the world am I going to get the value of high back?

Don't Fight the Framework The original call to MergeSort had low in $a2 and high in $a3 Recursive calls need to use the SAME registers for parameters ($a2 and $a3). (Disclaimer: Occasionally you'll need to use a helper function as a wrapper.) DO NOT USE s registers ($s0, $s1) to pass parameters for function calls!

Don't Fight the Framework Lets try using $s2 for high and $s0 for low sub $t1,$s2,$s0 srl $t1,$t1,1 #divide by 2 #add low to int middle add $s1,$t1,$s0 #making high = middle add $s2,$s1,$zero jal MergeSort # first call GUESS WHAT... IT DOESN'T WORK!

"I didn't like your algorithm... so I implemented another one" This is perfectly acceptable as long as: You explain your algorithm Your algorithm is generally efficient Your code is well documented and works...

"I didn't like your algorithm... so I implemented another one" It is generally not a good idea to "Freelance" if: You don't know what you're doing... We provide guidance, hints and algorithms in order to simplify the assignments... e.g. Recursive MergeSort is much "cleaner" and faster than Iterative MergeSort. These assignments are designed to give you experience with important aspects of language. (The Stack, Floating Point Types)

"I didn't like your algorithm... so I implemented another one" To be honest... Its much easier for us to grade and give partial credit for a non-working assignment that "followed the framework". In the real world- its much easier to debug and troubleshoot code which "followed the framework".

Today's Lab Project: Implementing a CRC Input We go bit by bit left to right through word Goals: Better Understanding of Masking Bit Manipulation, Shifting

Today's Lab Project: Implementing a CRC Input We go bit by bit left to right through word If you use Ethernet(802.3) (which you probably do...) You are using an error detection mechanism known as cyclic redundancy check

Input bits are processed one by one before going to Network register holding 32 bit CRC A copy of the contents of an Ethernet Packet are sent through a "machine" similar to one below before the packet is sent out on the Network (our model is simplified). A 32 bit "checksum" for the packet is calculated and is attached to the end of a packet.

Input in $a0 We go bit by bit left to right through word Today's Lab Project: Implementing a CRC Input in $a0 is word to have CRC calculated over Initially $v0 should be set to all 1s i.e. 0xFFFFFFFF Since we have 32 bits in our input... the "machine" will be cycled 32 times... (Sounds like a loop!) Output Register $v0

Today's Lab Project: Implementing a CRC Let's Figure Out What's Going On: 1. What do the black lines represent? 2. What is happening in the big picture? 3. What function does this symbol represent? 4. What is the truth table for the symbol's function? Input in $a0 We go bit by bit left to right through word Bits of Output Register $v0

Today's Lab Project: Implementing a CRC Let's Ask Questions: 1. If the value on the Feedback line is 0... what operation occurs in register $v0? 2. If value on feedback line is 1... what operations? Hint: examine xor operation Input in $a0 We go bit by bit left to right through word This is the Feedback Line

Let's write some big picture pseudocode.. For each of the 32 bits in $a0: 1. get the left most bit of CRC register ($v0) (HOW?) 2. get the current bit of the $a0 register that we're on (HOW?) 3. xor these 2 bits 4. if the xor is 0 then feedback line is 0... we should if the results is 1 then we should Input in $a0 We go bit by bit left to right through word

Things to do next: 1. Start thinking about subproblems... expand each of the earlier sections (1,2,3,4,5) 2. What do you need registers for? - Masks - to hold our bits - loop index Input in $a0 We go bit by bit left to right through word