Run with 10000 4

--------------------------------------------------------------------------------
-- Auto-annotated source: /home/cstaley/PolyWork/CountInversions3.c
--------------------------------------------------------------------------------
         Ir I1mr ILmr          Dr       D1mr DLmr         Dw   D1mw DLmw 

-- line 7 ----------------------------------------
          .    .    .           .          .    .          .      .    .  
          .    .    .           .          .    .          .      .    .  typedef struct {
          .    .    .           .          .    .          .      .    .    long tag1;
          .    .    .           .          .    .          .      .    .    long tag2;
          .    .    .           .          .    .          .      .    .    char name1[NAME_LEN];
          .    .    .           .          .    .          .      .    .    char name2[NAME_LEN];
          .    .    .           .          .    .          .      .    .  } CacheHog;
          .    .    .           .          .    .          .      .    .  
          4    0    0           0          0    0          1      0    0  int main(int argc) {
          2    1    0           0          0    0          2      0    0     int i, j, numHogs, numInv1 = 0, numInv2 = 0;
          .    .    .           .          .    .          .      .    .     int tileSize, iBase, iLim, jBase, jLim;
          .    .    .           .          .    .          .      .    .     CacheHog *vals;
          .    .    .           .          .    .          .      .    .  
          7    1    1           0          0    0          4      0    0     scanf("%d %d", &numHogs, &tileSize);
          5    1    0           1          0    0          4      1    0     vals = calloc(sizeof(CacheHog), numHogs);
     40,005    2    1      30,002          0    0          1      0    0     for (i = 0; i < numHogs; i++) {
     60,000    0    0      40,000          0    0     10,000 10,000    0        vals[i].tag1 = numHogs - i;
     60,000    0    0      40,000          0    0     10,000      0    0        vals[i].tag2 = numHogs + i;
          .    .    .           .          .    .          .      .    .     }
          .    .    .           .          .    .          .      .    .  
     12,505    1    1       7,502          0    0      2,501      0    0     for (iBase = 0; iBase < numHogs; iBase = iLim) {
     17,500    1    1       7,500          0    0      2,500      0    0        iLim = iBase + tileSize < numHogs ? iBase + tileSize : numHogs; 
          .    .    .           .          .    .          .      .    .       
          .    .    .           .          .    .          .      .    .        // Check within the tile 
     55,000    1    1      37,500          0    0      2,500      0    0        for (i = iBase; i < iLim; i++)
    130,000    1    0      75,000          0    0     10,000      0    0           for (j = i+1; j < iLim; j++) {
    150,000    0    0      90,000      9,996    0          0      0    0              if (vals[i].tag1 > vals[j].tag1)
     15,000    1    0      15,000          0    0          0      0    0                 numInv1++;
    150,000    0    0      90,000          0    0          0      0    0              if (vals[i].tag2 > vals[j].tag2)
          .    .    .           .          .    .          .      .    .                 numInv2++;
          .    .    .           .          .    .          .      .    .           }
          .    .    .           .          .    .          .      .    .  
          .    .    .           .          .    .          .      .    .        // Check all following tiles, exhausting each completely wrt tile i
 15,633,750    1    1   9,378,750          0    0  3,126,250      0    0        for (jBase = iLim; jBase < numHogs; jBase = jLim) {
 21,866,250    1    0   9,371,250          0    0  3,123,750      0    0           jLim = jBase + tileSize < numHogs ? jBase + tileSize : numHogs;
 68,722,500    1    0  46,856,250          0    0  3,123,750      0    0           for (i = iBase; i < iLim; i++)
274,890,000    0    0 187,425,000          0    0 12,495,000      0    0              for (j = jBase; j < jLim; j++) {
499,800,000    1    1 299,880,000 21,858,750    0          0      0    0                 if (vals[i].tag1 > vals[j].tag1)
 49,980,000    1    0  49,980,000          0    0          0      0    0                    numInv1++;
499,800,000    0    0 299,880,000          0    0          0      0    0                 if (vals[i].tag2 > vals[j].tag2)
          .    .    .           .          .    .          .      .    .                    numInv2++;
          .    .    .           .          .    .          .      .    .              }
          .    .    .           .          .    .          .      .    .        }
          .    .    .           .          .    .          .      .    .     }
          .    .    .           .          .    .          .      .    .              
          7    1    0           2          0    0          4      0    0     printf("Inversion counts: %d %d \n", numInv1, numInv2);
          3    0    0           1          0    0          2      0    0     free(vals);
          .    .    .           .          .    .          .      .    .     
          1    0    0           0          0    0          0      0    0     return 0;
          2    0    0           2          0    0          0      0    0  }

--------------------------------------------------------------------------------