// Check that adjacent objects in an array are ordered.
// If not, it reports an error
void check(void **A, int N, int M) {
int i;
void *x, *y;
struct intval *pi;
for (i = N + 1; i <= M; i++) {
x = A[i-1]; y = A[i];
if ( compareIntVal(y, x) < 0 ) {
pi = (struct intval *) y;
printf("%s %d %s %d %s", "Error at: ", i,
" A[i]: ", pi->val, "\n");
}
}
} // end check
// validateAlgorithm0 is used to check algorithm alg1 against a
// trusted algorithm alg2
// The check consists of making sure that starting from identical
// inputs they produce identical outputs
// alg1 is a parallel one, alg2 is sequential
void validateAlgorithm0(char* label, int siz, void (*alg1)(), void (*alg2)() ) {
printf("%s on size: %d\n", label, siz);
// create the input for alg1 ...
struct intval *pi;
void **A = myMalloc("validateAlgorithm0 1", sizeof(pi) * siz);
int i;
for (i = 0; i < siz; i++) {
pi = myMalloc("validateAlgorithm0 2", sizeof (struct intval));
A[i] = pi;
};
fillarray(A, siz, 100);
// ... sort it
int compareIntVal();
(*alg1)(A, siz, compareIntVal, NUMTHREADS);
// create the input for alg2 ...
void **B = myMalloc("validateAlgorithm0 3", sizeof(pi) * siz);
// int i;
// struct intval *pi;
for (i = 0; i < siz; i++) {
pi = myMalloc("validateAlgorithm0 4", sizeof (struct intval));
B[i] = pi;
};
fillarray(B, siz, 100);
// ... sort it
// int compareIntVal();
(*alg2)(B, siz, compareIntVal);
// check that the two outputs are the same
int foundError = 0;
for (i = 0; i < siz; i++)
// if ( A[i] != B[i] ) {
if ( compareIntVal(A[i], B[i]) != 0 ) {
printf("validate error i: %d\n", i);
foundError = 1;
}
if ( !foundError )
printf("NO error found ...\n");
} // end validateAlgorithm0
void validateFourSortBT() { // validation on the Bentley bench test against heapsort
printf("Entering validateFourSortBT Sawtooth ........\n");
// printf("Entering validateFourSortBT Rand2 ........\n");
// printf("Entering validateFourSortBT Plateau ........\n");
// printf("Entering validateFourSortBT Shuffle ........\n");
// printf("Entering validateFourSortBT Stagger ........\n");
int sortcBTime, cut2Time, T;
int seed = 666;
int z;
int siz = 1024*1024;
// int limit = 1024 * 1024 * 16 + 1;
// int seedLimit = 32 * 1024;
int limit = siz + 1;
// int seedLimit = 32;
int seedLimit = 1;
float frac;
while (siz <= limit) {
printf("%s %d %s %d %s", "siz: ", siz, " seedLimit: ", seedLimit, "\n");
// int A[siz];
struct intval *pi;
void **A = myMalloc("compareAlgorithms0 1", sizeof(pi) * siz);
void **B = myMalloc("compareAlgorithms0 3", sizeof(pi) * siz);
// construct array
int i;
for (i = 0; i < siz; i++) {
pi = myMalloc("compareAlgorithms0 2", sizeof (struct intval));
A[i] = pi;
pi = myMalloc("compareAlgorithms0 4", sizeof (struct intval));
B[i] = pi;
};
// warm up the process
fillarray(A, siz, seed);
int TFill, m, tweak;
int sortcBCnt, cut2Cnt; // , sortcBCntx, cut2Cntx;
int sumQsortB, sumCut2; // , sumQsortBx, sumCut2x;
// for (z = 0; z < 3; z++) { // repeat to check stability
for (z = 0; z < 1; z++) { // repeat to check stability
sortcBCnt = cut2Cnt = sumQsortB = sumCut2 = 0;
// sortcBCntx = cut2Cntx = sumQsortBx = sumCut2x = 0;
for (m = 1; m < 2 * siz; m = m * 2) {
// m = 1024 * 1024; {
// m = 1; {
for (tweak = 0; tweak <= 5; tweak++ ) {
// tweak = 5; {
sortcBTime = 0; cut2Time = 0;
TFill = clock();
for (seed = 0; seed < seedLimit; seed++)
sawtooth(A, siz, m, tweak);
// rand2(A, siz, m, tweak, seed);
// plateau(A, siz, m, tweak);
// shuffle(A, siz, m, tweak, seed);
// stagger(A, siz, m, tweak);
TFill = clock() - TFill;
T = clock();
for (seed = 0; seed < seedLimit; seed++) {
sawtooth(A, siz, m, tweak);
// rand2(A, siz, m, tweak, seed);
// plateau(A, siz, m, tweak);
// shuffle(A, siz, m, tweak, seed);
// stagger(A, siz, m, tweak);
callHeapSort(A, siz, compareIntVal);
}
sortcBTime = sortcBTime + clock() - T - TFill;
sumQsortB += sortcBTime;
// if ( 4 != tweak ) sumQsortBx += sortcBTime;
T = clock();
for (seed = 0; seed < seedLimit; seed++) {
sawtooth(B, siz, m, tweak);
// rand2(B, siz, m, tweak, seed);
// plateau(B, siz, m, tweak);
// shuffle(B, siz, m, tweak, seed);
// stagger(B, siz, m, tweak);
foursort(B, siz, compareIntVal, NUMTHREADS);
}
cut2Time = cut2Time + clock() - T - TFill;
sumCut2 += cut2Time;
// if ( 4 != tweak ) sumCut2x += cut2Time;
printf("Size: %d m: %d tweak: %d ", siz, m, tweak);
printf("sortcBTime: %d ", sortcBTime);
printf("Cut2Time: %d ", cut2Time);
frac = 0;
if ( sortcBTime != 0 ) frac = cut2Time / ( 1.0 * sortcBTime );
printf("frac: %f \n", frac);
if ( sortcBTime < cut2Time ) sortcBCnt++;
else cut2Cnt++;
for (i = 0; i < siz; i++) {
if ( compareIntVal(A[i], B[i]) != 0 ) {
printf("***** validateFourSortBT m: %i tweak: %i at i: %i\n",
m, tweak, i);
exit(0);
}
}
}
printf("sumQsortB: %i sumCut2: %i frac: %f",
sumQsortB, sumCut2, (sumCut2/(1.0 * sumQsortB)));
printf(" sortcBCnt: %i cut2Cnt: %i\n", sortcBCnt, cut2Cnt);
}
frac = 0;
if ( sumQsortB != 0 ) frac = sumCut2 / ( 1.0 * sumQsortB );
printf("Measurements:\n");
printf("sumQsortB: %i sumCut2: %i frac: %f",
sumQsortB, sumCut2, (sumCut2/(1.0 * sumQsortB)));
printf(" sortcBCnt: %i cut2Cnt: %i\n", sortcBCnt, cut2Cnt);
// printf("sumQsortBx: %i sumCut2x: %i", sumQsortBx, sumCut2x);
// printf(" sortcBCntx: %i cut2Cntx: %i\n", sortcBCntx, cut2Cntx);
}
// free array
for (i = 0; i < siz; i++) {
free(A[i]); free(B[i]);
};
free(A); free(B);
siz = siz * 2;
seedLimit = seedLimit / 2;
}
} // end validateFourSortBT
