contrib/bzip2-1.0/blocksort.c

   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 /*-------------------------------------------------------------*/