1 2 /*-------------------------------------------------------------*/ 3 /*--- Block sorting machinery ---*/ 4 /*--- blocksort.c ---*/ 5 /*-------------------------------------------------------------*/ 6 7 /* ------------------------------------------------------------------ 8 This file is part of bzip2/libbzip2, a program and library for 9 lossless, block-sorting data compression. 10 11 bzip2/libbzip2 version 1.0.5 of 10 December 2007 12 Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org> 13 14 Please read the WARNING, DISCLAIMER and PATENTS sections in the 15 README file. 16 17 This program is released under the terms of the license contained 18 in the file LICENSE. 19 ------------------------------------------------------------------ */ 20 21 22 #include "bzlib_private.h" 23 24 /*---------------------------------------------*/ 25 /*--- Fallback O(N log(N)^2) sorting ---*/ 26 /*--- algorithm, for repetitive blocks ---*/ 27 /*---------------------------------------------*/ 28 29 /*---------------------------------------------*/ 30 static 31 __inline__ 32 void fallbackSimpleSort ( UInt32* fmap, 33 UInt32* eclass, 34 Int32 lo, 35 Int32 hi ) 36 { 37 Int32 i, j, tmp; 38 UInt32 ec_tmp; 39 40 if (lo == hi) return; 41 42 if (hi - lo > 3) { 43 for ( i = hi-4; i >= lo; i-- ) { 44 tmp = fmap[i]; 45 ec_tmp = eclass[tmp]; 46 for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 ) 47 fmap[j-4] = fmap[j]; 48 fmap[j-4] = tmp; 49 } 50 } 51 52 for ( i = hi-1; i >= lo; i-- ) { 53 tmp = fmap[i]; 54 ec_tmp = eclass[tmp]; 55 for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ ) 56 fmap[j-1] = fmap[j]; 57 fmap[j-1] = tmp; 58 } 59 } 60 61 62 /*---------------------------------------------*/ 63 #define fswap(zz1, zz2) \ 64 { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } 65 66 #define fvswap(zzp1, zzp2, zzn) \ 67 { \ 68 Int32 yyp1 = (zzp1); \ 69 Int32 yyp2 = (zzp2); \ 70 Int32 yyn = (zzn); \ 71 while (yyn > 0) { \ 72 fswap(fmap[yyp1], fmap[yyp2]); \ 73 yyp1++; yyp2++; yyn--; \ 74 } \ 75 } 76 77 78 #define fmin(a,b) ((a) < (b)) ? (a) : (b) 79 80 #define fpush(lz,hz) { stackLo[sp] = lz; \ 81 stackHi[sp] = hz; \ 82 sp++; } 83 84 #define fpop(lz,hz) { sp--; \ 85 lz = stackLo[sp]; \ 86 hz = stackHi[sp]; } 87 88 #define FALLBACK_QSORT_SMALL_THRESH 10 89 #define FALLBACK_QSORT_STACK_SIZE 100 90 91 92 static 93 void fallbackQSort3 ( UInt32* fmap, 94 UInt32* eclass, 95 Int32 loSt, 96 Int32 hiSt ) 97 { 98 Int32 unLo, unHi, ltLo, gtHi, n, m; 99 Int32 sp, lo, hi; 100 UInt32 med, r, r3; 101 Int32 stackLo[FALLBACK_QSORT_STACK_SIZE]; 102 Int32 stackHi[FALLBACK_QSORT_STACK_SIZE]; 103 104 r = 0; 105 106 sp = 0; 107 fpush ( loSt, hiSt ); 108 109 while (sp > 0) { 110 111 AssertH ( sp < FALLBACK_QSORT_STACK_SIZE - 1, 1004 ); 112 113 fpop ( lo, hi ); 114 if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) { 115 fallbackSimpleSort ( fmap, eclass, lo, hi ); 116 continue; 117 } 118 119 /* Random partitioning. Median of 3 sometimes fails to 120 avoid bad cases. Median of 9 seems to help but 121 looks rather expensive. This too seems to work but 122 is cheaper. Guidance for the magic constants 123 7621 and 32768 is taken from Sedgewick's algorithms 124 book, chapter 35. 125 */ 126 r = ((r * 7621) + 1) % 32768; 127 r3 = r % 3; 128 if (r3 == 0) med = eclass[fmap[lo]]; else 129 if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else 130 med = eclass[fmap[hi]]; 131 132 unLo = ltLo = lo; 133 unHi = gtHi = hi; 134 135 while (1) { 136 while (1) { 137 if (unLo > unHi) break; 138 n = (Int32)eclass[fmap[unLo]] - (Int32)med; 139 if (n == 0) { 140 fswap(fmap[unLo], fmap[ltLo]); 141 ltLo++; unLo++; 142 continue; 143 }; 144 if (n > 0) break; 145 unLo++; 146 } 147 while (1) { 148 if (unLo > unHi) break; 149 n = (Int32)eclass[fmap[unHi]] - (Int32)med; 150 if (n == 0) { 151 fswap(fmap[unHi], fmap[gtHi]); 152 gtHi--; unHi--; 153 continue; 154 }; 155 if (n < 0) break; 156 unHi--; 157 } 158 if (unLo > unHi) break; 159 fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--; 160 } 161 162 AssertD ( unHi == unLo-1, "fallbackQSort3(2)" ); 163 164 if (gtHi < ltLo) continue; 165 166 n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n); 167 m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m); 168 169 n = lo + unLo - ltLo - 1; 170 m = hi - (gtHi - unHi) + 1; 171 172 if (n - lo > hi - m) { 173 fpush ( lo, n ); 174 fpush ( m, hi ); 175 } else { 176 fpush ( m, hi ); 177 fpush ( lo, n ); 178 } 179 } 180 } 181 182 #undef fmin 183 #undef fpush 184 #undef fpop 185 #undef fswap 186 #undef fvswap 187 #undef FALLBACK_QSORT_SMALL_THRESH 188 #undef FALLBACK_QSORT_STACK_SIZE 189 190 191 /*---------------------------------------------*/ 192 /* Pre: 193 nblock > 0 194 eclass exists for [0 .. nblock-1] 195 ((UChar*)eclass) [0 .. nblock-1] holds block 196 ptr exists for [0 .. nblock-1] 197 198 Post: 199 ((UChar*)eclass) [0 .. nblock-1] holds block 200 All other areas of eclass destroyed 201 fmap [0 .. nblock-1] holds sorted order 202 bhtab [ 0 .. 2+(nblock/32) ] destroyed 203 */ 204 205 #define SET_BH(zz) bhtab[(zz) >> 5] |= (1 << ((zz) & 31)) 206 #define CLEAR_BH(zz) bhtab[(zz) >> 5] &= ~(1 << ((zz) & 31)) 207 #define ISSET_BH(zz) (bhtab[(zz) >> 5] & (1 << ((zz) & 31))) 208 #define WORD_BH(zz) bhtab[(zz) >> 5] 209 #define UNALIGNED_BH(zz) ((zz) & 0x01f) 210 211 static 212 void fallbackSort ( UInt32* fmap, 213 UInt32* eclass, 214 UInt32* bhtab, 215 Int32 nblock, 216 Int32 verb ) 217 { 218 Int32 ftab[257]; 219 Int32 ftabCopy[256]; 220 Int32 H, i, j, k, l, r, cc, cc1; 221 Int32 nNotDone; 222 Int32 nBhtab; 223 UChar* eclass8 = (UChar*)eclass; 224 225 /*-- 226 Initial 1-char radix sort to generate 227 initial fmap and initial BH bits. 228 --*/ 229 if (verb >= 4) 230 VPrintf0 ( " bucket sorting ...\n" ); 231 for (i = 0; i < 257; i++) ftab[i] = 0; 232 for (i = 0; i < nblock; i++) ftab[eclass8[i]]++; 233 for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i]; 234 for (i = 1; i < 257; i++) ftab[i] += ftab[i-1]; 235 236 for (i = 0; i < nblock; i++) { 237 j = eclass8[i]; 238 k = ftab[j] - 1; 239 ftab[j] = k; 240 fmap[k] = i; 241 } 242 243 nBhtab = 2 + (nblock / 32); 244 for (i = 0; i < nBhtab; i++) bhtab[i] = 0; 245 for (i = 0; i < 256; i++) SET_BH(ftab[i]); 246 247 /*-- 248 Inductively refine the buckets. Kind-of an 249 "exponential radix sort" (!), inspired by the 250 Manber-Myers suffix array construction algorithm. 251 --*/ 252 253 /*-- set sentinel bits for block-end detection --*/ 254 for (i = 0; i < 32; i++) { 255 SET_BH(nblock + 2*i); 256 CLEAR_BH(nblock + 2*i + 1); 257 } 258 259 /*-- the log(N) loop --*/ 260 H = 1; 261 while (1) { 262 263 if (verb >= 4) 264 VPrintf1 ( " depth %6d has ", H ); 265 266 j = 0; 267 for (i = 0; i < nblock; i++) { 268 if (ISSET_BH(i)) j = i; 269 k = fmap[i] - H; if (k < 0) k += nblock; 270 eclass[k] = j; 271 } 272 273 nNotDone = 0; 274 r = -1; 275 while (1) { 276 277 /*-- find the next non-singleton bucket --*/ 278 k = r + 1; 279 while (ISSET_BH(k) && UNALIGNED_BH(k)) k++; 280 if (ISSET_BH(k)) { 281 while (WORD_BH(k) == 0xffffffff) k += 32; 282 while (ISSET_BH(k)) k++; 283 } 284 l = k - 1; 285 if (l >= nblock) break; 286 while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++; 287 if (!ISSET_BH(k)) { 288 while (WORD_BH(k) == 0x00000000) k += 32; 289 while (!ISSET_BH(k)) k++; 290 } 291 r = k - 1; 292 if (r >= nblock) break; 293 294 /*-- now [l, r] bracket current bucket --*/ 295 if (r > l) { 296 nNotDone += (r - l + 1); 297 fallbackQSort3 ( fmap, eclass, l, r ); 298 299 /*-- scan bucket and generate header bits-- */ 300 cc = -1; 301 for (i = l; i <= r; i++) { 302 cc1 = eclass[fmap[i]]; 303 if (cc != cc1) { SET_BH(i); cc = cc1; }; 304 } 305 } 306 } 307 308 if (verb >= 4) 309 VPrintf1 ( "%6d unresolved strings\n", nNotDone ); 310 311 H *= 2; 312 if (H > nblock || nNotDone == 0) break; 313 } 314 315 /*-- 316 Reconstruct the original block in 317 eclass8 [0 .. nblock-1], since the 318 previous phase destroyed it. 319 --*/ 320 if (verb >= 4) 321 VPrintf0 ( " reconstructing block ...\n" ); 322 j = 0; 323 for (i = 0; i < nblock; i++) { 324 while (ftabCopy[j] == 0) j++; 325 ftabCopy[j]--; 326 eclass8[fmap[i]] = (UChar)j; 327 } 328 AssertH ( j < 256, 1005 ); 329 } 330 331 #undef SET_BH 332 #undef CLEAR_BH 333 #undef ISSET_BH 334 #undef WORD_BH 335 #undef UNALIGNED_BH 336 337 338 /*---------------------------------------------*/ 339 /*--- The main, O(N^2 log(N)) sorting ---*/ 340 /*--- algorithm. Faster for "normal" ---*/ 341 /*--- non-repetitive blocks. ---*/ 342 /*---------------------------------------------*/ 343 344 /*---------------------------------------------*/ 345 static 346 __inline__ 347 Bool mainGtU ( UInt32 i1, 348 UInt32 i2, 349 UChar* block, 350 UInt16* quadrant, 351 UInt32 nblock, 352 Int32* budget ) 353 { 354 Int32 k; 355 UChar c1, c2; 356 UInt16 s1, s2; 357 358 AssertD ( i1 != i2, "mainGtU" ); 359 /* 1 */ 360 c1 = block[i1]; c2 = block[i2]; 361 if (c1 != c2) return (c1 > c2); 362 i1++; i2++; 363 /* 2 */ 364 c1 = block[i1]; c2 = block[i2]; 365 if (c1 != c2) return (c1 > c2); 366 i1++; i2++; 367 /* 3 */ 368 c1 = block[i1]; c2 = block[i2]; 369 if (c1 != c2) return (c1 > c2); 370 i1++; i2++; 371 /* 4 */ 372 c1 = block[i1]; c2 = block[i2]; 373 if (c1 != c2) return (c1 > c2); 374 i1++; i2++; 375 /* 5 */ 376 c1 = block[i1]; c2 = block[i2]; 377 if (c1 != c2) return (c1 > c2); 378 i1++; i2++; 379 /* 6 */ 380 c1 = block[i1]; c2 = block[i2]; 381 if (c1 != c2) return (c1 > c2); 382 i1++; i2++; 383 /* 7 */ 384 c1 = block[i1]; c2 = block[i2]; 385 if (c1 != c2) return (c1 > c2); 386 i1++; i2++; 387 /* 8 */ 388 c1 = block[i1]; c2 = block[i2]; 389 if (c1 != c2) return (c1 > c2); 390 i1++; i2++; 391 /* 9 */ 392 c1 = block[i1]; c2 = block[i2]; 393 if (c1 != c2) return (c1 > c2); 394 i1++; i2++; 395 /* 10 */ 396 c1 = block[i1]; c2 = block[i2]; 397 if (c1 != c2) return (c1 > c2); 398 i1++; i2++; 399 /* 11 */ 400 c1 = block[i1]; c2 = block[i2]; 401 if (c1 != c2) return (c1 > c2); 402 i1++; i2++; 403 /* 12 */ 404 c1 = block[i1]; c2 = block[i2]; 405 if (c1 != c2) return (c1 > c2); 406 i1++; i2++; 407 408 k = nblock + 8; 409 410 do { 411 /* 1 */ 412 c1 = block[i1]; c2 = block[i2]; 413 if (c1 != c2) return (c1 > c2); 414 s1 = quadrant[i1]; s2 = quadrant[i2]; 415 if (s1 != s2) return (s1 > s2); 416 i1++; i2++; 417 /* 2 */ 418 c1 = block[i1]; c2 = block[i2]; 419 if (c1 != c2) return (c1 > c2); 420 s1 = quadrant[i1]; s2 = quadrant[i2]; 421 if (s1 != s2) return (s1 > s2); 422 i1++; i2++; 423 /* 3 */ 424 c1 = block[i1]; c2 = block[i2]; 425 if (c1 != c2) return (c1 > c2); 426 s1 = quadrant[i1]; s2 = quadrant[i2]; 427 if (s1 != s2) return (s1 > s2); 428 i1++; i2++; 429 /* 4 */ 430 c1 = block[i1]; c2 = block[i2]; 431 if (c1 != c2) return (c1 > c2); 432 s1 = quadrant[i1]; s2 = quadrant[i2]; 433 if (s1 != s2) return (s1 > s2); 434 i1++; i2++; 435 /* 5 */ 436 c1 = block[i1]; c2 = block[i2]; 437 if (c1 != c2) return (c1 > c2); 438 s1 = quadrant[i1]; s2 = quadrant[i2]; 439 if (s1 != s2) return (s1 > s2); 440 i1++; i2++; 441 /* 6 */ 442 c1 = block[i1]; c2 = block[i2]; 443 if (c1 != c2) return (c1 > c2); 444 s1 = quadrant[i1]; s2 = quadrant[i2]; 445 if (s1 != s2) return (s1 > s2); 446 i1++; i2++; 447 /* 7 */ 448 c1 = block[i1]; c2 = block[i2]; 449 if (c1 != c2) return (c1 > c2); 450 s1 = quadrant[i1]; s2 = quadrant[i2]; 451 if (s1 != s2) return (s1 > s2); 452 i1++; i2++; 453 /* 8 */ 454 c1 = block[i1]; c2 = block[i2]; 455 if (c1 != c2) return (c1 > c2); 456 s1 = quadrant[i1]; s2 = quadrant[i2]; 457 if (s1 != s2) return (s1 > s2); 458 i1++; i2++; 459 460 if (i1 >= nblock) i1 -= nblock; 461 if (i2 >= nblock) i2 -= nblock; 462 463 k -= 8; 464 (*budget)--; 465 } 466 while (k >= 0); 467 468 return False; 469 } 470 471 472 /*---------------------------------------------*/ 473 /*-- 474 Knuth's increments seem to work better 475 than Incerpi-Sedgewick here. Possibly 476 because the number of elems to sort is 477 usually small, typically <= 20. 478 --*/ 479 static 480 Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280, 481 9841, 29524, 88573, 265720, 482 797161, 2391484 }; 483 484 static 485 void mainSimpleSort ( UInt32* ptr, 486 UChar* block, 487 UInt16* quadrant, 488 Int32 nblock, 489 Int32 lo, 490 Int32 hi, 491 Int32 d, 492 Int32* budget ) 493 { 494 Int32 i, j, h, bigN, hp; 495 UInt32 v; 496 497 bigN = hi - lo + 1; 498 if (bigN < 2) return; 499 500 hp = 0; 501 while (incs[hp] < bigN) hp++; 502 hp--; 503 504 for (; hp >= 0; hp--) { 505 h = incs[hp]; 506 507 i = lo + h; 508 while (True) { 509 510 /*-- copy 1 --*/ 511 if (i > hi) break; 512 v = ptr[i]; 513 j = i; 514 while ( mainGtU ( 515 ptr[j-h]+d, v+d, block, quadrant, nblock, budget 516 ) ) { 517 ptr[j] = ptr[j-h]; 518 j = j - h; 519 if (j <= (lo + h - 1)) break; 520 } 521 ptr[j] = v; 522 i++; 523 524 /*-- copy 2 --*/ 525 if (i > hi) break; 526 v = ptr[i]; 527 j = i; 528 while ( mainGtU ( 529 ptr[j-h]+d, v+d, block, quadrant, nblock, budget 530 ) ) { 531 ptr[j] = ptr[j-h]; 532 j = j - h; 533 if (j <= (lo + h - 1)) break; 534 } 535 ptr[j] = v; 536 i++; 537 538 /*-- copy 3 --*/ 539 if (i > hi) break; 540 v = ptr[i]; 541 j = i; 542 while ( mainGtU ( 543 ptr[j-h]+d, v+d, block, quadrant, nblock, budget 544 ) ) { 545 ptr[j] = ptr[j-h]; 546 j = j - h; 547 if (j <= (lo + h - 1)) break; 548 } 549 ptr[j] = v; 550 i++; 551 552 if (*budget < 0) return; 553 } 554 } 555 } 556 557 558 /*---------------------------------------------*/ 559 /*-- 560 The following is an implementation of 561 an elegant 3-way quicksort for strings, 562 described in a paper "Fast Algorithms for 563 Sorting and Searching Strings", by Robert 564 Sedgewick and Jon L. Bentley. 565 --*/ 566 567 #define mswap(zz1, zz2) \ 568 { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } 569 570 #define mvswap(zzp1, zzp2, zzn) \ 571 { \ 572 Int32 yyp1 = (zzp1); \ 573 Int32 yyp2 = (zzp2); \ 574 Int32 yyn = (zzn); \ 575 while (yyn > 0) { \ 576 mswap(ptr[yyp1], ptr[yyp2]); \ 577 yyp1++; yyp2++; yyn--; \ 578 } \ 579 } 580 581 static 582 __inline__ 583 UChar mmed3 ( UChar a, UChar b, UChar c ) 584 { 585 UChar t; 586 if (a > b) { t = a; a = b; b = t; }; 587 if (b > c) { 588 b = c; 589 if (a > b) b = a; 590 } 591 return b; 592 } 593 594 #define mmin(a,b) ((a) < (b)) ? (a) : (b) 595 596 #define mpush(lz,hz,dz) { stackLo[sp] = lz; \ 597 stackHi[sp] = hz; \ 598 stackD [sp] = dz; \ 599 sp++; } 600 601 #define mpop(lz,hz,dz) { sp--; \ 602 lz = stackLo[sp]; \ 603 hz = stackHi[sp]; \ 604 dz = stackD [sp]; } 605 606 607 #define mnextsize(az) (nextHi[az]-nextLo[az]) 608 609 #define mnextswap(az,bz) \ 610 { Int32 tz; \ 611 tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \ 612 tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \ 613 tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; } 614 615 616 #define MAIN_QSORT_SMALL_THRESH 20 617 #define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT) 618 #define MAIN_QSORT_STACK_SIZE 100 619 620 static 621 void mainQSort3 ( UInt32* ptr, 622 UChar* block, 623 UInt16* quadrant, 624 Int32 nblock, 625 Int32 loSt, 626 Int32 hiSt, 627 Int32 dSt, 628 Int32* budget ) 629 { 630 Int32 unLo, unHi, ltLo, gtHi, n, m, med; 631 Int32 sp, lo, hi, d; 632 633 Int32 stackLo[MAIN_QSORT_STACK_SIZE]; 634 Int32 stackHi[MAIN_QSORT_STACK_SIZE]; 635 Int32 stackD [MAIN_QSORT_STACK_SIZE]; 636 637 Int32 nextLo[3]; 638 Int32 nextHi[3]; 639 Int32 nextD [3]; 640 641 sp = 0; 642 mpush ( loSt, hiSt, dSt ); 643 644 while (sp > 0) { 645 646 AssertH ( sp < MAIN_QSORT_STACK_SIZE - 2, 1001 ); 647 648 mpop ( lo, hi, d ); 649 if (hi - lo < MAIN_QSORT_SMALL_THRESH || 650 d > MAIN_QSORT_DEPTH_THRESH) { 651 mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget ); 652 if (*budget < 0) return; 653 continue; 654 } 655 656 med = (Int32) 657 mmed3 ( block[ptr[ lo ]+d], 658 block[ptr[ hi ]+d], 659 block[ptr[ (lo+hi)>>1 ]+d] ); 660 661 unLo = ltLo = lo; 662 unHi = gtHi = hi; 663 664 while (True) { 665 while (True) { 666 if (unLo > unHi) break; 667 n = ((Int32)block[ptr[unLo]+d]) - med; 668 if (n == 0) { 669 mswap(ptr[unLo], ptr[ltLo]); 670 ltLo++; unLo++; continue; 671 }; 672 if (n > 0) break; 673 unLo++; 674 } 675 while (True) { 676 if (unLo > unHi) break; 677 n = ((Int32)block[ptr[unHi]+d]) - med; 678 if (n == 0) { 679 mswap(ptr[unHi], ptr[gtHi]); 680 gtHi--; unHi--; continue; 681 }; 682 if (n < 0) break; 683 unHi--; 684 } 685 if (unLo > unHi) break; 686 mswap(ptr[unLo], ptr[unHi]); unLo++; unHi--; 687 } 688 689 AssertD ( unHi == unLo-1, "mainQSort3(2)" ); 690 691 if (gtHi < ltLo) { 692 mpush(lo, hi, d+1 ); 693 continue; 694 } 695 696 n = mmin(ltLo-lo, unLo-ltLo); mvswap(lo, unLo-n, n); 697 m = mmin(hi-gtHi, gtHi-unHi); mvswap(unLo, hi-m+1, m); 698 699 n = lo + unLo - ltLo - 1; 700 m = hi - (gtHi - unHi) + 1; 701 702 nextLo[0] = lo; nextHi[0] = n; nextD[0] = d; 703 nextLo[1] = m; nextHi[1] = hi; nextD[1] = d; 704 nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1; 705 706 if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); 707 if (mnextsize(1) < mnextsize(2)) mnextswap(1,2); 708 if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); 709 710 AssertD (mnextsize(0) >= mnextsize(1), "mainQSort3(8)" ); 711 AssertD (mnextsize(1) >= mnextsize(2), "mainQSort3(9)" ); 712 713 mpush (nextLo[0], nextHi[0], nextD[0]); 714 mpush (nextLo[1], nextHi[1], nextD[1]); 715 mpush (nextLo[2], nextHi[2], nextD[2]); 716 } 717 } 718 719 #undef mswap 720 #undef mvswap 721 #undef mpush 722 #undef mpop 723 #undef mmin 724 #undef mnextsize 725 #undef mnextswap 726 #undef MAIN_QSORT_SMALL_THRESH 727 #undef MAIN_QSORT_DEPTH_THRESH 728 #undef MAIN_QSORT_STACK_SIZE 729 730 731 /*---------------------------------------------*/ 732 /* Pre: 733 nblock > N_OVERSHOOT 734 block32 exists for [0 .. nblock-1 +N_OVERSHOOT] 735 ((UChar*)block32) [0 .. nblock-1] holds block 736 ptr exists for [0 .. nblock-1] 737 738 Post: 739 ((UChar*)block32) [0 .. nblock-1] holds block 740 All other areas of block32 destroyed 741 ftab [0 .. 65536 ] destroyed 742 ptr [0 .. nblock-1] holds sorted order 743 if (*budget < 0), sorting was abandoned 744 */ 745 746 #define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8]) 747 #define SETMASK (1 << 21) 748 #define CLEARMASK (~(SETMASK)) 749 750 static 751 void mainSort ( UInt32* ptr, 752 UChar* block, 753 UInt16* quadrant, 754 UInt32* ftab, 755 Int32 nblock, 756 Int32 verb, 757 Int32* budget ) 758 { 759 Int32 i, j, k, ss, sb; 760 Int32 runningOrder[256]; 761 Bool bigDone[256]; 762 Int32 copyStart[256]; 763 Int32 copyEnd [256]; 764 UChar c1; 765 Int32 numQSorted; 766 UInt16 s; 767 if (verb >= 4) VPrintf0 ( " main sort initialise ...\n" ); 768 769 /*-- set up the 2-byte frequency table --*/ 770 for (i = 65536; i >= 0; i--) ftab[i] = 0; 771 772 j = block[0] << 8; 773 i = nblock-1; 774 for (; i >= 3; i -= 4) { 775 quadrant[i] = 0; 776 j = (j >> 8) | ( ((UInt16)block[i]) << 8); 777 ftab[j]++; 778 quadrant[i-1] = 0; 779 j = (j >> 8) | ( ((UInt16)block[i-1]) << 8); 780 ftab[j]++; 781 quadrant[i-2] = 0; 782 j = (j >> 8) | ( ((UInt16)block[i-2]) << 8); 783 ftab[j]++; 784 quadrant[i-3] = 0; 785 j = (j >> 8) | ( ((UInt16)block[i-3]) << 8); 786 ftab[j]++; 787 } 788 for (; i >= 0; i--) { 789 quadrant[i] = 0; 790 j = (j >> 8) | ( ((UInt16)block[i]) << 8); 791 ftab[j]++; 792 } 793 794 /*-- (emphasises close relationship of block & quadrant) --*/ 795 for (i = 0; i < BZ_N_OVERSHOOT; i++) { 796 block [nblock+i] = block[i]; 797 quadrant[nblock+i] = 0; 798 } 799 800 if (verb >= 4) VPrintf0 ( " bucket sorting ...\n" ); 801 802 /*-- Complete the initial radix sort --*/ 803 for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1]; 804 805 s = block[0] << 8; 806 i = nblock-1; 807 for (; i >= 3; i -= 4) { 808 s = (s >> 8) | (block[i] << 8); 809 j = ftab[s] -1; 810 ftab[s] = j; 811 ptr[j] = i; 812 s = (s >> 8) | (block[i-1] << 8); 813 j = ftab[s] -1; 814 ftab[s] = j; 815 ptr[j] = i-1; 816 s = (s >> 8) | (block[i-2] << 8); 817 j = ftab[s] -1; 818 ftab[s] = j; 819 ptr[j] = i-2; 820 s = (s >> 8) | (block[i-3] << 8); 821 j = ftab[s] -1; 822 ftab[s] = j; 823 ptr[j] = i-3; 824 } 825 for (; i >= 0; i--) { 826 s = (s >> 8) | (block[i] << 8); 827 j = ftab[s] -1; 828 ftab[s] = j; 829 ptr[j] = i; 830 } 831 832 /*-- 833 Now ftab contains the first loc of every small bucket. 834 Calculate the running order, from smallest to largest 835 big bucket. 836 --*/ 837 for (i = 0; i <= 255; i++) { 838 bigDone [i] = False; 839 runningOrder[i] = i; 840 } 841 842 { 843 Int32 vv; 844 Int32 h = 1; 845 do h = 3 * h + 1; while (h <= 256); 846 do { 847 h = h / 3; 848 for (i = h; i <= 255; i++) { 849 vv = runningOrder[i]; 850 j = i; 851 while ( BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv) ) { 852 runningOrder[j] = runningOrder[j-h]; 853 j = j - h; 854 if (j <= (h - 1)) goto zero; 855 } 856 zero: 857 runningOrder[j] = vv; 858 } 859 } while (h != 1); 860 } 861 862 /*-- 863 The main sorting loop. 864 --*/ 865 866 numQSorted = 0; 867 868 for (i = 0; i <= 255; i++) { 869 870 /*-- 871 Process big buckets, starting with the least full. 872 Basically this is a 3-step process in which we call 873 mainQSort3 to sort the small buckets [ss, j], but 874 also make a big effort to avoid the calls if we can. 875 --*/ 876 ss = runningOrder[i]; 877 878 /*-- 879 Step 1: 880 Complete the big bucket [ss] by quicksorting 881 any unsorted small buckets [ss, j], for j != ss. 882 Hopefully previous pointer-scanning phases have already 883 completed many of the small buckets [ss, j], so 884 we don't have to sort them at all. 885 --*/ 886 for (j = 0; j <= 255; j++) { 887 if (j != ss) { 888 sb = (ss << 8) + j; 889 if ( ! (ftab[sb] & SETMASK) ) { 890 Int32 lo = ftab[sb] & CLEARMASK; 891 Int32 hi = (ftab[sb+1] & CLEARMASK) - 1; 892 if (hi > lo) { 893 if (verb >= 4) 894 VPrintf4 ( " qsort [0x%x, 0x%x] " 895 "done %d this %d\n", 896 ss, j, numQSorted, hi - lo + 1 ); 897 mainQSort3 ( 898 ptr, block, quadrant, nblock, 899 lo, hi, BZ_N_RADIX, budget 900 ); 901 numQSorted += (hi - lo + 1); 902 if (*budget < 0) return; 903 } 904 } 905 ftab[sb] |= SETMASK; 906 } 907 } 908 909 AssertH ( !bigDone[ss], 1006 ); 910 911 /*-- 912 Step 2: 913 Now scan this big bucket [ss] so as to synthesise the 914 sorted order for small buckets [t, ss] for all t, 915 including, magically, the bucket [ss,ss] too. 916 This will avoid doing Real Work in subsequent Step 1's. 917 --*/ 918 { 919 for (j = 0; j <= 255; j++) { 920 copyStart[j] = ftab[(j << 8) + ss] & CLEARMASK; 921 copyEnd [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1; 922 } 923 for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) { 924 k = ptr[j]-1; if (k < 0) k += nblock; 925 c1 = block[k]; 926 if (!bigDone[c1]) 927 ptr[ copyStart[c1]++ ] = k; 928 } 929 for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) { 930 k = ptr[j]-1; if (k < 0) k += nblock; 931 c1 = block[k]; 932 if (!bigDone[c1]) 933 ptr[ copyEnd[c1]-- ] = k; 934 } 935 } 936 937 AssertH ( (copyStart[ss]-1 == copyEnd[ss]) 938 || 939 /* Extremely rare case missing in bzip2-1.0.0 and 1.0.1. 940 Necessity for this case is demonstrated by compressing 941 a sequence of approximately 48.5 million of character 942 251; 1.0.0/1.0.1 will then die here. */ 943 (copyStart[ss] == 0 && copyEnd[ss] == nblock-1), 944 1007 ) 945 946 for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK; 947 948 /*-- 949 Step 3: 950 The [ss] big bucket is now done. Record this fact, 951 and update the quadrant descriptors. Remember to 952 update quadrants in the overshoot area too, if 953 necessary. The "if (i < 255)" test merely skips 954 this updating for the last bucket processed, since 955 updating for the last bucket is pointless. 956 957 The quadrant array provides a way to incrementally 958 cache sort orderings, as they appear, so as to 959 make subsequent comparisons in fullGtU() complete 960 faster. For repetitive blocks this makes a big 961 difference (but not big enough to be able to avoid 962 the fallback sorting mechanism, exponential radix sort). 963 964 The precise meaning is: at all times: 965 966 for 0 <= i < nblock and 0 <= j <= nblock 967 968 if block[i] != block[j], 969 970 then the relative values of quadrant[i] and 971 quadrant[j] are meaningless. 972 973 else { 974 if quadrant[i] < quadrant[j] 975 then the string starting at i lexicographically 976 precedes the string starting at j 977 978 else if quadrant[i] > quadrant[j] 979 then the string starting at j lexicographically 980 precedes the string starting at i 981 982 else 983 the relative ordering of the strings starting 984 at i and j has not yet been determined. 985 } 986 --*/ 987 bigDone[ss] = True; 988 989 if (i < 255) { 990 Int32 bbStart = ftab[ss << 8] & CLEARMASK; 991 Int32 bbSize = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart; 992 Int32 shifts = 0; 993 994 while ((bbSize >> shifts) > 65534) shifts++; 995 996 for (j = bbSize-1; j >= 0; j--) { 997 Int32 a2update = ptr[bbStart + j]; 998 UInt16 qVal = (UInt16)(j >> shifts); 999 quadrant[a2update] = qVal; 1000 if (a2update < BZ_N_OVERSHOOT) 1001 quadrant[a2update + nblock] = qVal; 1002 } 1003 AssertH ( ((bbSize-1) >> shifts) <= 65535, 1002 ); 1004 } 1005 1006 } 1007 1008 if (verb >= 4) 1009 VPrintf3 ( " %d pointers, %d sorted, %d scanned\n", 1010 nblock, numQSorted, nblock - numQSorted ); 1011 } 1012 1013 #undef BIGFREQ 1014 #undef SETMASK 1015 #undef CLEARMASK 1016 1017 1018 /*---------------------------------------------*/ 1019 /* Pre: 1020 nblock > 0 1021 arr2 exists for [0 .. nblock-1 +N_OVERSHOOT] 1022 ((UChar*)arr2) [0 .. nblock-1] holds block 1023 arr1 exists for [0 .. nblock-1] 1024 1025 Post: 1026 ((UChar*)arr2) [0 .. nblock-1] holds block 1027 All other areas of block destroyed 1028 ftab [ 0 .. 65536 ] destroyed 1029 arr1 [0 .. nblock-1] holds sorted order 1030 */ 1031 void BZ2_blockSort ( EState* s ) 1032 { 1033 UInt32* ptr = s->ptr; 1034 UChar* block = s->block; 1035 UInt32* ftab = s->ftab; 1036 Int32 nblock = s->nblock; 1037 Int32 verb = s->verbosity; 1038 Int32 wfact = s->workFactor; 1039 UInt16* quadrant; 1040 Int32 budget; 1041 Int32 budgetInit; 1042 Int32 i; 1043 1044 if (nblock < 10000) { 1045 fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); 1046 } else { 1047 /* Calculate the location for quadrant, remembering to get 1048 the alignment right. Assumes that &(block[0]) is at least 1049 2-byte aligned -- this should be ok since block is really 1050 the first section of arr2. 1051 */ 1052 i = nblock+BZ_N_OVERSHOOT; 1053 if (i & 1) i++; 1054 quadrant = (UInt16*)(&(block[i])); 1055 1056 /* (wfact-1) / 3 puts the default-factor-30 1057 transition point at very roughly the same place as 1058 with v0.1 and v0.9.0. 1059 Not that it particularly matters any more, since the 1060 resulting compressed stream is now the same regardless 1061 of whether or not we use the main sort or fallback sort. 1062 */ 1063 if (wfact < 1 ) wfact = 1; 1064 if (wfact > 100) wfact = 100; 1065 budgetInit = nblock * ((wfact-1) / 3); 1066 budget = budgetInit; 1067 1068 mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget ); 1069 if (verb >= 3) 1070 VPrintf3 ( " %d work, %d block, ratio %5.2f\n", 1071 budgetInit - budget, 1072 nblock, 1073 (float)(budgetInit - budget) / 1074 (float)(nblock==0 ? 1 : nblock) ); 1075 if (budget < 0) { 1076 if (verb >= 2) 1077 VPrintf0 ( " too repetitive; using fallback" 1078 " sorting algorithm\n" ); 1079 fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); 1080 } 1081 } 1082 1083 s->origPtr = -1; 1084 for (i = 0; i < s->nblock; i++) 1085 if (ptr[i] == 0) 1086 { s->origPtr = i; break; }; 1087 1088 AssertH( s->origPtr != -1, 1003 ); 1089 } 1090 1091 1092 /*-------------------------------------------------------------*/ 1093 /*--- end blocksort.c ---*/ 1094 /*-------------------------------------------------------------*/ 1095