MIPS Assembly Recursion: Fibonacci, Binary Search, Mergesort

Transcription

1 MIPS Assembly Recursion: Fibonacci, Binary Search, Mergesort CptS 260 Intro to Computer Architecture Week 7.2 Wed 2013/10/02

2 A Computer Scientist s Perspective of Recursion Don t worry about what a function means histogram, complexity, (let the math guys do this) Just do its primitive operations base cases (reductionistic) recursive calls calculate arguments jal save/restore intermediate results combine the results add, subtract,

3 Fibonacci Sequence [Leonardo of Pisa] Rabbit pairs in month n New rabbits start breeding at 2 months (Rabbits are immortal?) F(1) = 1 F(2) = 1 F(n) = F(n-1) + F(n-2) Binet s formula Growth rate is: exponential! binary tree of recursive calls F n =

4 MIPS Example (1 arg, 2 base): Fibonacci F: # int F($a0 : int n) // F(0) = 0; F(1) = 1; F(n) = F(n 1) + F(n 2) bgt $a0, 0, base1 # if (n <= 0) li $v0, 0 jr $ra # return 0; base1: bgt $a0, 1, recur # if (n == 1) recur: li $v0, 1 jr $ra # return 1; # // else addi $sp, $sp, 12 # stack push # 8: _ F(n 1) _ sw $a0, 4($sp) # 4: _ n _ sw $ra, 0($sp) # 0: _ ra _ addi $a0, $a0, 1 # (n 1) jal F # v0 = F(n 1) sw $v0, 8($sp) save it F(n 1) addi $a0, $a0, 1 # (n 2) jal F # v0 = F(n 2) lw $t0, 8($sp) restore it add $v0, $v0, $t0 # + F(n 1) pre-allocate space lw $a0, 4($sp) lw $ra, 0($sp) addi $sp, $sp, 12 jr $ra

5 Total Computable and Primitive Recursive Total Function well-defined for all input values Computable Function while-loops (unbounded) Primitive Recursive Function do-loops/for-loops (bounded)

6 Total Computable but Not Primitive Recursive Ackermann function A(0, n) = n + 1 A(m, 0) = A(m 1, 1) m > 0 A(m, n) = A(m 1, A(m, n 1)) m, n > 0 recursive call as an argument: that s weird Still easy to implement 2 base cases at most 2 subtractions at most 2 function calls (in C / Java / MIPS)

7 MIPS Example: Ackermann Ak: # int Ak($a0: int m, $a1: int n) bgt $a0, 0, Ak_push # if (m <= 0) addi $v0, $a1, 1 # return n + 1; jr $ra Ak_push: Code is about as long as Fibonacci Ak_pop: reak: addi $sp, $sp, 8 # stack push sw $a0, 4($sp) # 4: _ m _ sw $ra, 0($sp) # 0: _ ra _ bgt $a1, 0, reak # if A(m, 0) addi $a0, $a0, 1 # m 1 li $a1, 1 # jal Ak # Ak(, 1) j Ak_pop # return ; # $a0 still m addi $a1, $a1, 1 # n 1 jal Ak # v0 = Ak(m, ) # $a0 persists, so it s still m addi $a0, $a0, 1 # m 1 move $a1, $v0 # jal Ak # Ak(, Ak(m, n 1)) # fall through lw lw $a0, 4($sp) $ra, 0($sp) addi $sp, $sp, 8 # pop jr $ra Run-time complexity is very different!! worse than exponential (!!)

8 Recursion on Data Structures Array algorithms binary search sort Tree algorithms recursive descent parser compilers serialization (save as/restore from) minimax search with alpha-beta pruning perfect-information games 2 players alternate turns best for me = worst for you disk file network send/recv XML, HTML remote procedure call chess checkers Zillions of Games

9 Binary Search: C Instantiate with T_ = int: int * BS<int>(int n, int * lo, int * hi) template<typename T_> T_ * BS(T_ t, T_ * lo, T_ * hi) if (lo > hi) return 0; T_ * mid = ALIGN((lo + hi) / 2); if (t == *mid) return lo; if (t < *mid) return BS(t, lo, mid 1); else // t > *mid return BS(t, mid + 1, hi);

10 Binary Search: MIPS # int * BS<int>(n, lo, hi) // returns &n if found, or 0 if not found BS: ble $a1, $a2, Bmd # if (lo > hi) Bgr: li $v0, 0 # $a0 still n jr $ra # return 0; addi $a2, $t5, 4 # mid + 1 Bmd: # calc. $t5 = mid (details not shown) lw $t6, 0($t5) # *mid bne $a0, $t6, Brec # if (t == ) move $v0, $a1 jr $ra # return lo; Brec: addi $sp, $sp, 4 # stack push sw $ra, 0($sp) # 0: _ ra _ bgt $a0, $t6, Bgr # if (<) # $a0 still n # $a1 still lo addi $a2, $t5, 4 # mid 1 jal BS # BS(t, lo, ) j Bpop # return # $a2 still hi jal BS # fall through Bpop: lw $ra, 0($sp) addi $sp, $sp, 4 # pop jr $ra if (t < *mid) return BS(t, lo, mid 1); else // t > *mid return BS(t, mid + 1, hi);

11 Mergesort Mergesort(int * A, int * E) if (E A <= 1) return; int * Split(int * I, int * J) int * M = Split(A, E); Mergesort (A, M); int n = J I; Mergesort (M, E); Merge (A, M, E); int mid = (n + 1) / 2; return I + mid; Merge (int * A, int * M, int * E) for (int * I = A, * J = M; I!= M && J!= E; ) if (*I < *J) Insert(*I++); else Insert(*J++); int * Split(int * I, int * J) return I + (J I + 1) / 2; // in half (odd element to lower half) // C pointer arithmetic: // difference of 2 pointers // # of elements between them // pointer + int // address of int-th element

12 Mergesort (And Why We Don t Use It) Mergesort(int * A, int * E) split if (E A <= 1) return; split int * M = Split(A, E); Mergesort (A, M); 5 3 Mergesort (M, E); Merge (A, M, E); Merge (int * A, int * M, int * E) for (int * I = A, * J = M; merge merge Can t merge-in-place Need temporary arrays Usually: linked lists I!= M && J!= E; ) if (*I < *J) merge Insert appends to end Insert(*I++); else Insert(*J++);