CSC Data Structures, Fall, 2009

Transcription

1 An example of using gdb. CSC Data Structures, Fall, 2009 Dr. Dale E. Parson, parson@kutztown.edu, Below are listings for files timesort.cxx and queueofints.h from our sorting assignment. I have planted a bug at lines 55 and 60 of queueofints.h. First I will blow this up and debug the core file created by the fault on bill. Then I will debug the running process in order to illustrate breakpoints. PART 1: Debugging a core dump from an exploding process. Run the program. -bash-3.00$ gmake clean build test_merge /bin/rm -f *.o *.class.jar core *.exe *.obj *.pyc /bin/rm -f timesort timesort.out timesort.dif /bin/bash -c "g++ -c -I. -g StringToInteger.cxx -o StringToInteger.o" /bin/bash -c "g++ -c -I. -g timesort.cxx -o timesort.o" g++ StringToInteger.o timesort.o -o timesort./timesort merge Generating integers Start timer and sort using mergesort. gmake: *** [test_merge] Debug the core file. Use where to see where execution blew up, print to print variable bindings, l ( list ) to list the program, and up and down to navigate up and down the call stack to calling and called functions made visible by where. -bash-3.00$ gdb./timesort core GNU gdb (startup messages) Loaded symbols for /lib/ld.so.1 Core was generated by `./timesort merge '. Program terminated with signal 11, Segmentation fault. #0 0x00013ec4 in queueofints::peek (this=0xffbff7ac, isvalid=@0xffbff6a7) at queueofints.h:68 68 result = buffer[head]; (gdb) where #0 0x00013ec4 in queueofints::peek (this=0xffbff7ac, isvalid=@0xffbff6a7) at queueofints.h:68 #1 0x000135cc in mergephase (merger=@0xffbff7c8, splitter=0xffbff798, runlen=2) at timesort.cxx:386 #2 0x000137e4 in mergesort (merger=@0xffbff7c8, splitter=0xffbff798) at timesort.cxx:416 #3 0x in imergesort (iarray=0x25780, left=0, right= ) at timesort.cxx:437 #4 0x in main (argc=4, argv=0xffbff914) at timesort.cxx:137 (gdb) print head $1 = (gdb) print count $2 = (gdb) print *this $3 = {buffer = 0xf67b90, Capacity = , count = , tail = 0, head = } (gdb) l 63 } 64 int peek(bool &isvalid) { 65 int result = 0 ; 66 isvalid = false ; 67 if (count > 0) { 68 result = buffer[head]; 69 isvalid = true ; 70 } 71 return result ; 72 } (gdb) You can see that the program is blowing up at line 68: result = buffer[head]; and that a head value of exceeds the queue s array capacity of The next logical thing is to look at the places in the code where the head field is adjusted, and try to determine why it gets set to a value greater than capacity. You may be able to reason that out without the debugger. We will use the debugger on a smaller array to be sorted instead. Before doing that, let s look at the up and down commands for inspecting the stack frames of calling function. (gdb) where #0 0x00013ec4 in queueofints::peek (this=0xffbff7ac, isvalid=@0xffbff6a7) at queueofints.h:68 #1 0x000135cc in mergephase (merger=@0xffbff7c8, splitter=0xffbff798, runlen=2) at timesort.cxx:386 #2 0x000137e4 in mergesort (merger=@0xffbff7c8, splitter=0xffbff798) at timesort.cxx:416 #3 0x in imergesort (iarray=0x25780, left=0, right= ) at timesort.cxx:437 #4 0x in main (argc=4, argv=0xffbff914) at timesort.cxx:137 (gdb) up #1 0x000135cc in mergephase (merger=@0xffbff7c8, splitter=0xffbff798, runlen=2) at timesort.cxx: int v1 = splitter[1].peek(ignoreme); (gdb) list 381 int srl[2] ; // remaining run lengths for each queue 382 srl[0] = runlen ; // both sides have contents, [0] is a full run 383 srl[1] = (splitter[1].size() < runlen)? splitter[1].size() : runlen ; 384 while (srl[0] > 0 && srl[1] > 0) { page 1 page 2

2 385 int v0 = splitter[0].peek(ignoreme); 386 int v1 = splitter[1].peek(ignoreme); 387 if (v0 <= v1) { 388 merger.enqueue(v0); 389 splitter[0].dequeue(); 390 srl[0] -= 1 ; (gdb) print v0 $4 = 645 (gdb) print v1 $5 = 0 (gdb) up #2 0x000137e4 in mergesort (merger=@0xffbff7c8, splitter=0xffbff798) at timesort.cxx: mergephase(merger, splitter, runlen); (gdb) print merger $6 = (queueofints {buffer = 0x25780, Capacity = , count = , tail = , head = } (gdb) print splitter $7 = (queueofints *) 0xffbff798 (gdb) print splitter[0] $8 = {buffer = 0x7c6988, Capacity = , count = , tail = 0, head = } (gdb) print splitter[1] $9 = {buffer = 0xf67b90, Capacity = , count = , tail = 0, head = } (gdb) down 2 #0 0x00013ec4 in queueofints::peek (this=0xffbff7ac, isvalid=@0xffbff6a7) at queueofints.h:68 68 result = buffer[head]; (gdb) quit Now we will run the process within the debugger using a smaller array. You can run the test using gmake to see what the command line looks like, and then adapt that to starting the process with gdb using the --args command line option. First run the command line using a smaller array to see whether the bug still appears, and then use gdb. -bash-3.00$ gmake clean build test_merge /bin/rm -f *.o *.class.jar core *.exe *.obj *.pyc /bin/rm -f timesort timesort.out timesort.dif /bin/bash -c "g++ -c -I. -g StringToInteger.cxx -o StringToInteger.o" /bin/bash -c "g++ -c -I. -g timesort.cxx -o timesort.o" g++ StringToInteger.o timesort.o -o timesort./timesort merge Generating integers Start timer and sort using mergesort. gmake: *** [test_merge] -bash-3.00$./timesort merge Generating integers Start timer and sort using mergesort. -bash-3.00$./timesort merge 20 1 Generating 20 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 2000 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 200 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 1000 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 500 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 250 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 275 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 375 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 300 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 325 integers. Start timer and sort using mergesort. -bash-3.00$./timesort merge Generating 350 integers. Start timer and sort using mergesort. An arrays size of 250 does the job. Here is how to run that process using gdb. -bash-3.00$ gdb --args./timesort merge GNU gdb This GDB was configured as "sparc-sun-solaris2.8"... (gdb) break main Breakpoint 1 at 0x11a38: file timesort.cxx, line 66. (gdb) run Starting program: /export/home/faculty/parson/private/csc237/timesort/timesort merge warning: Temporarily disabling breakpoints for unloaded shared library "/usr/lib/ld.so.1" page 3 page 4

3 Breakpoint 1, main (argc=4, argv=0xffbff8fc) at timesort.cxx:66 66 bool isbinarysearch = false, isprint = false ; I usually set any additional breakpoints of interest after setting a breakpoint at function main, and running the program until it hits that breakpoint. Sometimes if you set breakpoints before starting program execution, then the breakpoints do not work due to how UNIX processes load dynmaic code libraries. A gdb use can set breakpoints by saying: break FUNCTIONAME (for regular C functions) break CLASS::FUNCTIONNAME(for member functions of classes) break FILE:LINENUMBER (to break in the middle of a function) You can even add a condition to a breakpoint. (gdb) help break Set breakpoint at specified line or function. break [LOCATION] [thread THREADNUM] [if CONDITION] LOCATION may be a line number, function name, or "*" and an address. If a line number is specified, break at start of code for that line. If a function is specified, break at start of code for that function. If an address is specified, break at that exact address. With no LOCATION, uses current execution address of selected stack frame. This is useful for breaking on return to a stack frame. THREADNUM is the number from "info threads". CONDITION is a boolean expression. Multiple breakpoints at one place are permitted, and useful if conditional. Do "help breakpoints" for info on other commands dealing with breakpoints. (gdb) help breakpoints Making program stop at certain points. List of commands: awatch -- Set a watchpoint for an expression break -- Set breakpoint at specified line or function catch -- Set catchpoints to catch events clear -- Clear breakpoint at specified line or function commands -- Set commands to be executed when a breakpoint is hit condition -- Specify breakpoint number N to break only if COND is true delete -- Delete some breakpoints or auto-display expressions delete breakpoints -- Delete some breakpoints or auto-display expressions delete display -- Cancel some expressions to be displayed when program stops delete mem -- Delete memory region delete tracepoints -- Delete specified tracepoints disable -- Disable some breakpoints disable breakpoints -- Disable some breakpoints disable display -- Disable some expressions to be displayed when program stops disable mem -- Disable memory region disable tracepoints -- Disable specified tracepoints enable -- Enable some breakpoints enable delete -- Enable breakpoints and delete when hit enable display -- Enable some expressions to be displayed when program stops enable mem -- Enable memory region enable once -- Enable breakpoints for one hit enable tracepoints -- Enable specified tracepoints hbreak -- Set a hardware assisted breakpoint ignore -- Set ignore-count of breakpoint number N to COUNT rbreak -- Set a breakpoint for all functions matching REGEXP rwatch -- Set a read watchpoint for an expression tbreak -- Set a temporary breakpoint tcatch -- Set temporary catchpoints to catch events thbreak -- Set a temporary hardware assisted breakpoint watch -- Set a watchpoint for an expression Type "help" followed by command name for full documentation. Type "apropos word" to search for commands related to "word". Command name abbreviations are allowed if unambiguous. Since I know from debugging the core file that head is being set to a value > capacity, I will look for every place that head is set to a new value, and set a conditional breakpoint that triggers only if head > capacity. The only place that head is adjusted in this program is queueofints.h:55 so we start out by setting an unconditional breakpoint there. (gdb) break queueofints.h:55 Breakpoint 2 at 0x13d94: file queueofints.h, line 55. (gdb) cont Continuing. Generating 350 integers. Start timer and sort using mergesort. Breakpoint 2, queueofints::dequeue (this=0xffbff7b0) at queueofints.h:55 55 head = (head + 1) ; // THIS IS A BUG THAT WE WILL DEBUG WITH GDB You can use print to print out variable values, step to move forward one line at a time and also to call into functions or return from functions, and next to step over functions instead of going into them. Breakpoint 2, queueofints::dequeue (this=0xffbff7b0) at queueofints.h:55 55 head = (head + 1) ; // THIS IS A BUG THAT WE WILL DEBUG WITH GDB (gdb) print head $1 = 0 56 count-- ; page 5 page 6

4 (gdb) print head $2 = 1 (gdb) print count $3 = result = true ; (gdb) print count $4 = return result ; 63 } splitphase (merger=@0xffbff7b0, splitter=0xffbff780, runlen=1) at timesort.cxx: rl-- ; (gdb) It clearly will take a long time to get head up past capacity, so disable breakpoint 2 and set a new, conditional breakpoint. (gdb) break queueofints.h:56 if head >= Capacity Breakpoint 4 at 0x13da8: file queueofints.h, line 56. (gdb) cont Continuing. Breakpoint 4, queueofints::dequeue (this=0xffbff7b0) at queueofints.h:56 56 count-- ; (gdb) print head $7 = 350 (gdb) print Capacity $8 = 350 At this point you can probably figure out the cause of the bug. Typically a subset of the above gdb commands will be enough to allow you to debug any C++ program. Using gdb requires practice. 1 /** Taken from midterm237fall08.cxx 2 queueofints.h, a circular queue of ints, adapted from the CSC 237 midterm. 3 Dr. Dale Parson, Fall, */ 6 #include <iostream> 7 using namespace std ; 8 9 // Problem 1: 10 class queueofints { // fixed size circular queue class 11 private: 12 int *buffer ; // buffer for a circular queue 13 int Capacity ; // number of element slots available in buffer 14 int count ; // number of elements in queue 15 int tail ; // where to enqueue an element 16 int head ; // where to dequeue an element 17 public: 18 queueofints(int *Iarray, int Capacity, int Size) { 19 // STUDENTS NEED ONLY TO WRITE THE CONSTRUCTOR. 20 // THERE ARE NO OTHER CHANGES. 21 buffer = Iarray ; 22 this->capacity = Capacity ; 23 count = Size ; 24 // watch out for (Size % Capacity) when Capacity == 0, divides by 0! 25 tail = (Size == Capacity)? 0 : Size ; 26 head = 0 ; } 29 ~queueofints() { 30 } void printqueue() { 33 int hd = head, ct = count ; 34 while (ct > 0) { 35 cout << buffer[hd]; 36 hd = (hd + 1) % Capacity ; 37 ct-- ; 38 } 39 } bool enqueue(int value) { 42 bool result = false ; 43 if (count < Capacity) { 44 buffer[tail] = value; 45 tail = (tail + 1) % Capacity ; // wraps tail around to 0 46 count++ ; 47 result = true ; 48 } 49 return result ; 50 } 51 bool dequeue() { 52 bool result = false ; 53 if (count > 0) { 54 // head = (head + 1) % Capacity ; // wraps head around to 0 55 head = (head + 1) ; // THIS IS A BUG THAT WE WILL DEBUG WITH GDB 56 count-- ; 57 result = true ; 58 } 59 if (count == 0) { // THIS LINE WAS ADDED FOR MERGESORT TO WORK. page 7 page 8

5 WHY??? 60 // ANOTHER BUG head = tail = 0 ; 61 } 62 return result ; 63 } 64 int peek(bool &isvalid) { 65 int result = 0 ; 66 isvalid = false ; 67 if (count > 0) { 68 result = buffer[head]; 69 isvalid = true ; 70 } 71 return result ; 72 } 73 int size() { 74 return count ; 75 } 76 int capacity () { 77 return Capacity ; 78 } 79 } ; 1 /* timesort.cxx -- A test driver of various sorts & binary search. 2 3 CSC237, Fall, 2009, Dr. Dale Parson. 4 */ 5 6 // THE FOLLOWING EXIT CODES CONSTITUTE THE RETURN VALUES FROM MAIN: 7 static const int SUCCESS = 0 ; /* successful program execution */ 8 static const int PARMERR = 1 ; /* invalid command line values */ 9 10 #include <stdlib.h> 11 #include <sys/times.h> 12 #include <limits.h> #include <iostream> 15 #include StringToInteger.h 16 using namespace std ; 17 #include queueofints.h typedef void (*sortfunction)(int iarray[], int left, int right); 20 static void printarray(char *prompt, int iarray[], int numelems) ; 21 static void quicksort(int iarray[], int left, int right); 22 static void insertionsort(int iarray[], int left, int right); 23 static void selectionsort(int iarray[], int left, int right); 24 static void bubblesort(int iarray[], int left, int right); 25 static void radixsort(int iarray[], int left, int right); 26 static void imergesort(int iarray[], int left, int right); // BINARY SEARCH 29 static int * binsearch(int *iptr, int count, int key) { 30 if (count < 1 (count == 1 && iptr[0]!= key) 31 key < iptr[0] key > iptr[count-1]) { 32 return NULL ; 33 } else if (count == 1) { 34 return iptr ; 35 } else { 36 int half = count / 2 ; 37 if (key <= iptr[half-1]) { 38 return binsearch(iptr,half,key); 39 } else { 40 return binsearch(iptr+half,count-half, key); 41 } 42 } 43 } static const char *usage = 46 usage: timesort quick insertion selection bubble radix merge NUMELEMS SEED [ BP ] ; /* 49 Function: main main is a test driver that exercises implementations of 52 a timed named sort and binary search Parameters: See usage documentation above Exit value: SUCCESS is argv is OK, else PARMERR */ 61 int *intarray ; 62 int 63 main(const int argc, char *argv[]) { 64 int size, seed ; 65 bool validflag ; 66 bool isbinarysearch = false, isprint = false ; 67 sortfunction sortfunc = NULL ; 68 struct tms before, after ; 69 if (argc!= 4) { 70 if (argc == 5) { 71 // BP or PB or just P or B in last command line argument give 72 // true flags for binasry search(b) and print the array (P). page 9 page 10

6 73 if (*(argv[4]) == B *(argv[4]+1) == B ) { 74 isbinarysearch = true ; 75 } 76 if (*(argv[4]) == P *(argv[4]+1) == P ) { 77 isprint = true ; 78 } 79 if (! (isbinarysearch isprint)) { 80 // argv[4] is no good. 81 cerr << Invalid final command line argument, 82 << must be B and/or P: << argv[4] << endl ; 83 cerr << usage << endl ; 84 exit(parmerr); 85 } 86 } else { 87 cerr << usage << endl ; 88 exit(parmerr); 89 } 90 } 91 size = StringToInteger(argv[2], validflag); 92 if ((! validflag) size < 0) { 93 cerr << Invalid size: << argv[2] << endl ; 94 cerr << usage << endl ; 95 exit(parmerr); 96 } 97 seed = StringToInteger(argv[3], validflag); 98 if (! validflag) { 99 cerr << Invalid random number seed: << argv[3] << endl ; 100 cerr << usage << endl ; 101 exit(parmerr); 102 } 103 if (strcmp(argv[1], quick ) == 0) { 104 sortfunc = quicksort ; 105 } else if (strcmp(argv[1], insertion ) == 0) { 106 sortfunc = insertionsort ; 107 } else if (strcmp(argv[1], selection ) == 0) { 108 sortfunc = selectionsort ; 109 } else if (strcmp(argv[1], bubble ) == 0) { 110 sortfunc = bubblesort ; 111 } else if (strcmp(argv[1], radix ) == 0) { 112 sortfunc = radixsort ; 113 } else if (strcmp(argv[1], merge ) == 0) { 114 sortfunc = imergesort ; 115 } else { 116 cerr << Invalid sort function name: << argv[1] << endl ; 117 cerr << usage << endl ; 118 exit(parmerr); 119 } 120 srand(seed); 121 intarray = new int [ size ]; 122 cout << Generating << size << integers ; 123 cout.flush(); 124 for (int i = 0 ; i < size ; i++) { 125 if ((i & 0x0ffff) == 0) { // every print a. 126 cout <<. ; 127 cout.flush(); 128 } 129 intarray[i] = rand(); 130 } 131 if (isprint) { 132 cout << \nbefore SORTING: << endl << endl ; 133 printarray(argv[1], intarray, size); 134 } 135 cout << Start timer and sort using << argv[1] << sort. << endl ; 136 times(&before); 137 (*sortfunc)(intarray,0,size-1); 138 times(&after); 139 cout << User CPU time = 140 << ((after.tms_utime - before.tms_utime) / (double)clk_tck) 141 << secs, system CPU time = 142 << ((after.tms_stime - before.tms_stime) / (double)clk_tck) 143 << secs. << endl ; 144 if (isprint) { 145 cout << \nafter SORTING: << endl << endl ; 146 printarray(argv[1], intarray, size); 147 } 148 if (isbinarysearch) { 149 int key ; 150 cout << Enter search key: ; 151 cout.flush(); 152 cin >> key ; 153 while (! cin.eof()) { // Hit ctrl-c to break out 154 int *loc = binsearch(intarray, size, key); 155 if (loc == NULL) { 156 cout << Key << key << not found in array. << endl ; 157 } else { 158 cout << Key << key << found at array index 159 << loc - intarray <<. << endl ; 160 } 161 cout << endl << Enter search key: ; 162 cout.flush(); 163 cin >> key ; 164 } 165 cout << endl ; 166 } 167 return(success); 168 } page 11 page 12

7 static void printarray(char *prompt, int iarray[], int numelems) { 171 cout << prompt << \n ; 172 for (int i = 0 ; i < numelems ; i++) { 173 cout << iarray[i] << endl ; 174 } 175 } // If there are at least 3 elements, pick a value that is >= one 178 // of them and <= the other as the pivot. This decreases the probability 179 // of hitting a degenerate case where all or almost all elements partition 180 // to one side of the pivot. 181 // The return value is the pivot, also swapped into iarray[left]. 182 static int pickpivot(int iarray[], int left, int right) { 183 int result ; 184 int count = right - left + 1 ; 185 int mid = (left + right) / 2 ; 186 if (count < 3) { 187 result = iarray[left]; // [1] element or 50/50 odds for [2] 188 } else if ((iarray[mid] <= iarray[left] && iarray[left] <= iarray[right]) 189 (iarray[right] <= iarray[left] && iarray[left] <= iarray[mid])){ 190 result = iarray[left]; 191 } else if ((iarray[left] <= iarray[mid] && iarray[mid] <= iarray[right]) 192 (iarray[right] <= iarray[mid] && iarray[mid] <= iarray[left])){ 193 result = iarray[mid] ; 194 iarray[mid] = iarray[left] ; 195 iarray[left] = result ; 196 } else if ((iarray[mid] <= iarray[right] && iarray[right] <= iarray[left]) 197 (iarray[left] <= iarray[right] && iarray[right] <= iarray[mid])){ 198 result = iarray[right] ; 199 iarray[right] = iarray[left] ; 200 iarray[left] = result ; 201 } 202 return result ; 203 } // partition is a helper function for quicksort(). 206 // partition partitions an array into a left half and a right half, 207 // where all values in the left half or <= some pivot value, and 208 // all values in the right half are > that pivot value. 209 // partition may not divide the array exactly in half; left and right 210 // part would be a better term. 211 // RETURN index of the element around which the array is partitioned. 212 static int partition(int iarray[], int left, int right) { 213 int pivot = pickpivot(iarray, left, right); 214 int low = left + 1 ; // scan up looking for a too-high value 215 int high = right ; // scan down looking for a too-low value while (low < high) { // scan from both sides of array 218 while (low <= high && iarray[low] <= pivot) { // in correct side 219 low++; 220 } 221 while (low <= high && iarray[high] > pivot) { // in correct side 222 high--; 223 } 224 // If there are two elements on the wrong side, swap them. 225 if (low < high) { 226 int temp = iarray[high]; 227 iarray[high] = iarray[low]; 228 iarray[low] = temp ; 229 } 230 } 231 // We still need to place the pivot in the correct spot. 232 while (high > left && iarray[high] >= pivot) { 233 high--; 234 } 235 // swap pivot with a lower value if there is one 236 if (pivot > iarray[high]) { 237 iarray[left] = iarray[high]; 238 iarray[high] = pivot ; 239 return high; 240 } else { 241 return left ; 242 } 243 } // #define VERBOSE 246 #ifdef VERBOSE 247 // Implement the quick sort algorithm. 248 static void quicksort(int iarray[], int left, int right) { 249 static int depth = 0 ; 250 depth++ ; // used only to report recursion depth 251 if (left < right) { 252 // 1. Partition array so all values <= iarray[pivotlocation] of left 253 // of pivotlocation, and all values > pivotlocation are right of it. 254 int pivotlocation = partition(iarray, left, right); 255 // Sort the left partition. 256 cout << DEPTH << depth <<, PARTITION pivot value = 257 << iarray[pivotlocation] << AT INDEX << pivotlocation << endl ; 258 quicksort(iarray, left, pivotlocation-1); 259 cout << DEPTH << depth << ; 260 printarray( LEFT SORTED, iarray+left, pivotlocation-left); 261 // Sort the right partition. 262 quicksort(iarray, pivotlocation+1, right); 263 cout << DEPTH << depth << ; 264 printarray( RIGHT SORTED, page 13 page 14

8 265 iarray+pivotlocation+1, right-pivotlocation); 266 } 267 depth--; 268 } 269 #else 270 // Implement the quick sort algorithm. 271 static void quicksort(int iarray[], int left, int right) { 272 if (left < right) { 273 // 1. Partition array so all values <= iarray[pivotlocation] are left 274 // of pivotlocation, and all values > pivotlocation are right of it. 275 int pivotlocation = partition(iarray, left, right); 276 // Sort the left partition. 277 quicksort(iarray, left, pivotlocation-1); 278 // Sort the right partition. 279 quicksort(iarray, pivotlocation+1, right); 280 } 281 } 282 #endif static void insertionsort(int iarray[], int left, int right){ 285 // Grow the sorted left subarray by insertion of 1 at each step. 286 for (int uninsertedix = left+1 ; uninsertedix <= right ; uninsertedix++) { 287 int insvalue = iarray[uninsertedix]; 288 for (int dest = left ; dest < uninsertedix ; dest++) { 289 if (insvalue < iarray[dest]) { 290 for (int shift = uninsertedix ; shift > dest ; shift--) { 291 iarray[shift] = iarray[shift-1]; 292 } 293 iarray[dest] = insvalue ; 294 break ; 295 } 296 } 297 } 298 } static void selectionsort(int iarray[], int left, int right){ 301 for (int selix = left ; selix < right ; selix++) { 302 // Select value for slot selix. 303 int smallvalix = selix ; 304 // Search ahead in array for correct value. 305 for (int otherix = selix+1 ; otherix <= right ; otherix++) { 306 if (iarray[otherix] < iarray[smallvalix]) { 307 smallvalix = otherix ; 308 } 309 } 310 if (smallvalix!= selix) { 311 int tmp = iarray[selix]; 312 iarray[selix] = iarray[smallvalix]; 313 iarray[smallvalix] = tmp ; 314 } 315 } 316 } static void bubblesort(int iarray[], int left, int right){ 319 // Taken from textbook, page bool sorted = false ; // reset to false whenever a swap occurs 321 int size = right - left + 1 ; 322 for (int pass = 1 ; (pass < size) && (! sorted) ; pass++) { 323 // bubble the highest value to the end, if no swap occurs we re done 324 sorted = true ; 325 for (int ix = left ; ix <= right-pass ; ix++) { 326 if (iarray[ix] > iarray[ix+1]) { 327 int tmp = iarray[ix+1] ; 328 iarray[ix+1] = iarray[ix]; 329 iarray[ix] = tmp ; 330 sorted = false ; // We did not go through cleanly. 331 } 332 } 333 } 334 } static void radixsort(int iarray[], int left, int right) { 337 static int bitsinbyte = 8 ; 338 static int numbits = sizeof(int) * bitsinbyte ; 339 int size = right - left + 1 ; 340 int *binarray = new int [ 2 * size ]; 341 for (int i = 0, mask = 1 ; i < numbits ; i++, mask = mask << 1) { 342 int count[2] ; 343 count[0] = count[1] = 0 ; 344 for (int j = left ; j <= right ; j++) { 345 int bin = (iarray[j] & mask) >> i ; 346 binarray[bin * size + count[bin]] = iarray[j] ; 347 count[bin] = count[bin] + 1 ; 348 } 349 int restoreix = 0 ; 350 for (int bin = 0 ; bin < 2 ; bin++) { 351 for (int j = 0 ; j < count[bin] ; j++) { 352 iarray[restoreix++] = binarray[bin * size + j]; 353 } 354 } 355 } 356 delete [] binarray ; 357 } // This is the mergesort s splitphase for the assignment. 360 static void splitphase(queueofints &merger, queueofints splitter[2], page 15 page 16

9 361 int runlen) { 362 bool ignoreme ; // We only peek on queues with data, etc. 363 int qid = 0 ; 364 while (merger.size() > 0) { // while there are still runs to split ; 365 int rl = (merger.size() < runlen)? merger.size() : runlen ; 366 while (rl > 0) { 367 splitter[qid].enqueue(merger.peek(ignoreme)); 368 merger.dequeue(); 369 rl-- ; 370 } 371 qid = qid ^ 1 ; // switch to other splitter 372 } 373 } // This is the mergesort s mergephase for the assignment. 376 void mergephase(queueofints &merger, queueofints splitter[2], 377 int runlen) { 378 bool ignoreme ; 379 int qtodrain ; // The queue to drain when 1 runs ends, 380 while (splitter[0].size() > 0 && splitter[1].size() > 0) { 381 int srl[2] ; // remaining run lengths for each queue 382 srl[0] = runlen ; // both sides have contents, [0] is a full run 383 srl[1] = (splitter[1].size() < runlen)? splitter[1].size() : runlen ; 384 while (srl[0] > 0 && srl[1] > 0) { 385 int v0 = splitter[0].peek(ignoreme); 386 int v1 = splitter[1].peek(ignoreme); 387 if (v0 <= v1) { 388 merger.enqueue(v0); 389 splitter[0].dequeue(); 390 srl[0] -= 1 ; 391 } else { // v1 is less 392 merger.enqueue(v1); 393 splitter[1].dequeue(); 394 srl[1] -= 1 ; 395 } 396 } 397 int qtodrain = (srl[0] > 0)? 0 : 1 ; 398 while (srl[qtodrain] > 0) { 399 merger.enqueue(splitter[qtodrain].peek(ignoreme)); 400 splitter[qtodrain].dequeue(); 401 srl[qtodrain] -= 1 ; 402 } 403 } 404 // splitter[0] may have a leftover run or partial run 405 while (splitter[0].size() > 0) { 406 merger.enqueue(splitter[0].peek(ignoreme)); 407 splitter[0].dequeue(); 408 } 409 } // This is the function specified for the assignment. 412 void mergesort(queueofints &merger, queueofints splitter[2]) { 413 int runlen = 1 ; 414 while (runlen < merger.size()) { 415 splitphase(merger, splitter, runlen); 416 mergephase(merger, splitter, runlen); 417 runlen *= 2 ; 418 } 419 } // This function has the same signature as the other sorts above. 422 // It prepares arguments for the function as spec d by the assignment. 423 void imergesort(int *iarray, int left, int right) { 424 if (iarray == NULL left > right) { 425 // Don t try to do pointer arithemtic on a NULL pointer. 426 return ; 427 } 428 int *arraytosort = iarray + left ; 429 int count = right - left + 1 ; 430 queueofints merger(arraytosort, count, count); 431 int *aisle0 = new int [ count ]; // Like an aisle in the classroom. 432 int *aisle1 = new int [ count/2 ]; // Never more than 1/2 the elements. 433 queueofints splitter[] = { 434 queueofints(aisle0, count, 0), 435 queueofints(aisle1, count/2, 0) 436 }; 437 mergesort(merger, splitter); 438 delete [] aisle0 ; 439 delete [] aisle1 ; 440 } page 17 page 18