Reorganized for better spatial coherence, and sequential access.

--------------------------------------------------------------------------------
-- Auto-annotated source: /home/cstaley/PolyWork/CountInversions.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, k, numHogs, numInv1 = 0, numInv2 = 0;
          .    .    .           .          .    .      .      .    .     CacheHog *vals;
          .    .    .           .          .    .      .      .    .  
          5    1    1           0          0    0      3      0    0     scanf("%d", &numHogs);
          5    0    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;
          .    .    .           .          .    .      .      .    .     }
          .    .    .           .          .    .      .      .    .  
     40,005    2    1      30,002          0    0      1      0    0     for (i = 0; i < numHogs; i++)
200,050,000    0    0 150,015,000          0    0 10,000      0    0        for (j = i+1; j < numHogs; j++) {
499,950,000    1    1 299,970,000 50,004,967    0      0      0    0           if (vals[i].tag1 > vals[j].tag1)
 49,995,000    0    0  49,995,000          0    0      0      0    0              numInv1++;
499,950,000    1    0 299,970,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  }

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