void run_tests(int64_t *sizes, int sizes_cnt, int type) { int test, res; double usec1, usec2, diff; printf("-------\nRunning tests with %s:\n-------\n", test_names[type]); res = 0; diff = 0; printf("%-20s", "stdlib qsort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); qsort(dst, size, sizeof(int64_t), simple_cmp); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); #ifndef __linux__ res = 0; diff = 0; printf("%-20s", "stdlib heapsort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); heapsort(dst, size, sizeof(int64_t), simple_cmp); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "stdlib mergesort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); mergesort(dst, size, sizeof(int64_t), simple_cmp); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); #endif res = 0; diff = 0; printf("%-20s", "quick sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_quick_sort(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); if (MAXSIZE < 10000) { res = 0; diff = 0; printf("%-20s", "bubble sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_bubble_sort(dst, size); usec2 = utime(); verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "binary insertion sort\n"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_binary_insertion_sort(dst, size); usec2 = utime(); verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); } res = 0; diff = 0; printf("%-20s", "merge sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_merge_sort(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "heap sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_heap_sort(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "shell sort time"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_shell_sort(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "tim sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_tim_sort(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); res = 0; diff = 0; printf("%-20s", "in-place merge sort"); for (test = 0; test < sizes_cnt; test++) { int64_t size = sizes[test]; int64_t dst[size]; fill(dst, size, type); usec1 = utime(); sorter_merge_sort_in_place(dst, size); usec2 = utime(); res = verify(dst, size); if (!res) break; diff += usec2 - usec1; } printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff); }
void run_tests(void) { int i; int64_t arr[SIZE]; int64_t dst[SIZE]; double start_time; double end_time; double total_time; printf("Running tests\n"); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); qsort(dst, SIZE, sizeof(int64_t), simple_cmp); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("stdlib qsort time: %.2f us per iteration\n", total_time / RUNS); #ifndef __linux__ srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); heapsort(dst, SIZE, sizeof(int64_t), simple_cmp); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("stdlib heapsort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); mergesort(dst, SIZE, sizeof(int64_t), simple_cmp); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("stdlib mergesort time: %.2f us per iteration\n", total_time / RUNS); #endif srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_quick_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("quick sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_bubble_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("bubble sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_merge_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("merge sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_binary_insertion_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("binary insertion sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_heap_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("heap sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_shell_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("shell sort time: %.2f us per iteration\n", total_time / RUNS); srand48(SEED); total_time = 0.0; for (i = 0; i < RUNS; i++) { fill(arr, SIZE); memcpy(dst, arr, sizeof(int64_t) * SIZE); start_time = utime(); sorter_tim_sort(dst, SIZE); end_time = utime(); total_time += end_time - start_time; verify(dst, SIZE); } printf("tim sort time: %.2f us per iteration\n", total_time / RUNS); }