MIPS Assembly: Quicksort. CptS 260 Introduction to Computer Architecture Week 4.1 Mon 2014/06/30

Transcription

1 MIPS Assembly: Quicksort CptS 260 Introduction to Computer Architecture Week 4.1 Mon 2014/06/30

2 This Week 06/30 Mon Quicksort (overview) 07/01 Tue Quicksort (partition, HW6) 07/02 Wed Review HW1 HW5 Topics MIPS Simple Datapath MIPS Assembly Stack frame Function calling functions 07/03 Thu Midterm Exam In class Closed book (MIPS reference card will be attached)

3 Quicksort Yet Another Sorting Algorithm Hoare 1960 Best average-case performance! Best case ~ O(n log n) On average, 1.39 best-case worst-case ~ O(n 2 ) Online Resources Wikipedia, Quicksort, Repeated elements

4 Quicksort: Implementation Overview A Confluence of Big Concepts Array (of integers) Pointers (to integer) Recursion MIPS multiple return values: $v0, $v1 A: begin end Divide and Conquer Works for any array sequence! QUICKSORT( begin, end ) { if (begin >= end) return; p = PARTITION( begin, end ); QUICKSORT ( begin, p ); QUICKSORT ( p + 1, end ); } DIVIDE-AND-CONQUER( b, e ) { if (b >= e) return; p = SPLIT ( b, e ); DIVIDE-AND-CONQUER ( b, p ); DIVIDE-AND-CONQUER ( p + 1, e ); }

5 First Hurdle: HW Interface and Conversions The HW Interface is Non-Negotiable Heed the HW PDFs!! Heed all MIPS conventions: $a*, $v* Grading Harness A: HW PDF $a0: int A[] $a1: int len t: test_n You May Make Your Own Internal (Private) Interface $a0: int * lo = $a1: int * hi = You Do The Conversion!

6 Partition in Set Theory Set Theory / Ontology A disjoint covering Computer Science (algorithm) Given A set S and predicate P (function that returns true or false) partition(s, P) = S true S false rearranges elements returns: the midpoint

7 HW6: Outline of Tasks quicksort ( a0: int A[], a1: int len ) your adapter here quicksort_ab ( a0:, a1: ) { } // returns $v0 == end of S = partition( a0: word * lo, a1: word * hi ) { } // returns $v0 == start of S = // and $v1 == start of S >= enlarge ( a0: int * mid ) { } // returns nothing swap ( a0: int *, a1: int *) // exchanges *a0 and *a1

8 Quicksort: Three-Way ( Fat ) Partition HW6 Requirements Partition handles base cases Two return values: $v0, $v1 Many partition algorithms One write pointer (Wikipedia) Two-pointer swap Two write pointers Your Idea Here

9 Wikipedia: One read pointer, One write pointer In-place version left i wr right // Returns the pivot index int partition(a, left, right) int pivot := A[right] // Move pivot to end // swap A[pi], A[right] int wr := left for i = left to right 1 if A[i] <= pivot swap A[i], A[wr] ++wr // Move pivot to middle swap A[wr], A[right] return wr

10 Three-Way Partition using Two-Pointer Swap: Swapping the Pivot while (lo < hi) { // seek left lo hi 4 while (*lo <= pivot) ++lo; // seek right while (*hi >= pivot) hi; // exchange swap(lo++, hi ); 2 8 } // move pivot to end of S = swap(last, lo);

11 brute{sort,part}.asm Output

12 brutesort.asm Pretty Printing void brutesort_ettu # struct TestCase { int len; int A[]; }; ($a0 = TestCase * T) # prints T >A[] (before) # quicksort(t >len, T >A[]) # prints T >A[] (after) void print_array_withz ( $a0 = int A[], $a1 = int len, $a2 = int lenz) # a0 ae z0 ze \n len lenz void print_array_int # a0 a1 ae (with trailing space) ($a0 = int A[], $a1 = int * E) # in half-open interval [A, E) void print_int ($a0 : a) # a (with trailing space) void endl (void) # print_char( \n )

13 Swapping the Pivot: Enumerating Some Cases Contributing factors (?): Array parity: even odd Middle element (if odd) < p ==p > p Degenerate cases: lo-fails hi-fails

14 Swapping the Pivot: Ascending, Descending even odd swap to Ascending swap(last, lo); lo lo hi hi Descending

15 Swapping the Pivot: One Pointer Fails even odd swap to lo-fails lo lo hi hi hi-fails lo lo hi hi

16 3-Way Partition: Two Write Pointers # choose pivot # swap A[n, rand(1,n)] Pascal-like array notation: [1.. n] # 3-way partition 1 n i = 1, k = 1, p = n while i < p if A[i] < A[n] swap A[i++, k++] else if A[i] == A[n] swap A[i, --p] else i++ i k p end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] # move pivots to center m = min(p-k, n-p+1) swap A[k.. k+m-1, n-m+1.. n] # recursive sorts sort A[1, k-1] sort A[n-p+k+1, n]

17 3-Way Partition: Two Write Pointers # 3-way partition 1 n i = 1, k = 1, p = n while i < p if A[i] < A[n] swap A[i++, k++] else if A[i] == A[n] swap A[i, --p] else i++ i k p end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] # move pivots to center m = min(p-k, n-p+1) swap A[k.. k+m-1, n-m+1.. n] # recursive sorts sort A[1, k-1] sort A[n-p+k+1, n]

18 3-Way Partition: Two Write Pointers # 3-way partition 1 n i = 1, k = 1, p = n 5 while i < p if A[i] < A[n] swap A[i++, k++] 4 else if A[i] == A[n] swap A[i, --p] else i++ i k p end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] # move pivots to center m = min(p-k, n-p+1) swap A[k.. k+m-1, n-m+1.. n] # recursive sorts sort A[1, k-1] sort A[n-p+k+1, n]

19 3-Way Partition: Two Write Pointers # 3-way partition 1 n i = 1, k = 1, p = n 5 while i < p if A[i] < A[n] swap A[i++, k++] 4 else if A[i] == A[n] swap A[i, --p] else i++ i k p end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] # move pivots to center i m = min(p-k, n-p+1) swap A[k.. k+m-1, n-m+1.. n] k p # recursive sorts sort A[1, k-1] sort A[n-p+k+1, n]

20 3-Way Partition: Two Write Pointers # 3-way partition 1 n i = 1, k = 1, p = n while i < p if A[i] < A[n] swap A[i++, k++] else if A[i] == A[n] swap A[i, --p] i k p else i++ end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] # move pivots to center m = min(p-k, n-p+1) i swap A[k.. k+m-1, n-m+1.. n] k p # recursive sorts sort A[1, k-1] sort A[n-p+k+1, n]

21 3-Way Partition: Two Write Pointers 1 n # 3-way partition i = 1, k = 1, p = n i while i < p if A[i] < A[n] swap A[i++, k++] else if A[i] == A[n] swap A[i, --p] else i++ end invariant: A[p.. n] all equal invariant: A[1..k-1] < A[p.. n] < A[k..p-1] k p # min(12 4, ) = 5 # A[4.. 8, ] # move pivots to center m = min(p-k, n-p+1) swap A[k.. k+m-1, n-m+1.. n] $v0 $v1 # recursive sorts sort A[1, k-1] # A[01, 03] sort A[n-p+k+1, n] # A[08, 12]