More Better Assembly

1
More Better Assembly

• CSCI 136 Lab 4

2
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?

3
Can we write this a different way?

• move a2,s1 a2 middle
• addi a2,a2,1 a2 middle1

4
How about this?

• add a2, t0, 0 a2 middle
• addi a2, 1 a2 middle 1

5
Know You Instructions!Or at least look them up...

• ori t1, 0, 1 set t1 to 1
• srl a3, t0, t1 temp / 2

6

• 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

7
No need to clear registers!

• xor t0, t0, t0
• xor t1, t1, t1
• add t0, a0, t4 ourArrayupperIndex
• add t1, a1, t7 tempArraynewIndex

Sadly, this person cleared a very important
register on accident. Otherwise their program
would have actually worked. (
8
DeMorgan is Your Friend!

• NOT (A AND B) (NOT A) OR (NOT B)
• while(lowerIndexltmiddle upperIndexlthigh)
• bgt lowerIndex,middle,whileDone
• bgt upperIndex,high,whileDone
• This is just an example
• In many cases DeMorgans Law will make your life
  much, much easier.

9
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

10
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

11
Keep your register assignments!

• msfor1
• sle t0, t1, a3 count lt high
• beqz t0, msfor1End
• Set the address of ourArraycount
• add t2, a0, t4
• Set the address of tempArraynewIndex
• add t3, a1, t7
• lw t4, 0(t2) get ourArraycount
• sw t4, 0(t3) tempArraynewIndex
  ourArraycount
• 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

12
Uh. This isnt going to work!

• msfor1
• sle t0, t1, a3 count lt high
• beqz t0, msfor1End
• Set the address of ourArraycount
• add t2, a0, t4
• Set the address of tempArraynewIndex
• add t3, a1, t7
• lw t4, 0(t2) get ourArraycount
• sw t4, 0(t3) tempArraynewIndex
  ourArraycount
• 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

13
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

14
Stack For all paths through your codeWhat 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

15
Stack For all paths through your codeLeave It
Like You Found It!
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

• 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

When this function exits... the stack pointer is
8 bytes above where it started the function at...
TRANSLATION THIS ISN'T GOING TO WORK
16
What do these lines do?
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

• 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

17
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
  ourarraylowerIndex
• Write this in 2 instructions.

18
If you need it laterYou 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?
19
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!

20
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!

21
"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...

22
"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)

23
"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".

24
Today's Lab Project Implementing a CRC
Goals Better Understanding of Masking
Bit Manipulation, Shifting
...
...
30
29
28
27
26
1
2
31
0
25..3
Input We go bit by bit left to right
through word
00000000 00000000 10000000 00000000
25
Today's Lab Project Implementing a CRC
If you use Ethernet(802.3) (which you probably
do...) You are using an error detection
mechanism known as cyclic redundancy check
...
...
30
29
28
27
26
1
2
31
0
25..3
Input We go bit by bit left to right
through word
00000000 00000000 10000000 00000000
26
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.
register holding 32 bit CRC
...
...
30
29
28
27
26
1
2
31
0
25..3
Input bits are processed one by one before going
to Network
00000000 00000000 10000000 00000000
27
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
...
...
30
29
28
27
26
1
2
31
0
25..3
Input in a0 We go bit by bit left to
right through word
00000000 00000000 10000000 00000000
28
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?
Bits of Output Register v0
...
...
30
29
28
27
26
1
2
31
0
25..3
Input in a0 We go bit by bit left to
right through word
00000000 00000000 10000000 00000000
29
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...
This is the Feedback Line
...
...
30
29
28
27
26
1
2
31
0
25..3
Input in a0 We go bit by bit left to
right through word
00000000 00000000 10000000 00000000
30
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... 5. if the
results is 1 then we should...
...
...
30
29
28
27
26
1
2
31
0
25..3
Input in a0 We go bit by bit left to
right through word
00000000 00000000 10000000 00000000
31
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
...
...
30
29
28
27
26
1
2
31
0
25..3
Input in a0 We go bit by bit left to
right through word
00000000 00000000 10000000 00000000