Skip to content

Commit 1479806

Browse files
vidsinghalvidsinghal
committed
edit
1 parent c150277 commit 1479806

File tree

4 files changed

+182
-5
lines changed

4 files changed

+182
-5
lines changed

‎benchrunner/cxx/benchmarks.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ void quicksort_glibc_inplace(void *const pbase, size_t total_elems, size_t size,
2020
void *quicksort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
2121
void *quicksort(void *const pbase, size_t total_elems, size_t size);
2222
void quicksort_inplace_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
23-
void *quicksort_inplace(void *_a, size_t n, size_t es);
23+
template<typename T> T *quicksort_inplace(T *_a, size_t n);
2424
void *smergesort(void *const pbase, size_t total_elems, size_t size);
2525
void *smergesort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
2626
void *mergesort_par(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);

‎benchrunner/cxx/helpers.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,14 @@ static inline void SWAP(void *a, void *b, size_t elt_size)
5858
} while (--__size > 0);
5959
}
6060

61+
template<typename T>
62+
static inline void SWAP2(T *a, int i, int j)
63+
{
64+
T _tmp = a[i];
65+
a[i] = a[j];
66+
a[j] = _tmp;
67+
}
68+
6169
// -----------------------------------------------------------------------------
6270

6371
typedef struct slice_t_ {

‎benchrunner/cxx/main.cpp‎

Lines changed: 29 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,40 @@
11
#include <iostream>
22
#include "benchmarks.h"
33
#include "insertionsort.cpp"
4+
#include "quicksort.cpp"
45
#include "microbench.h"
56
#include "cbench.h"
7+
#include <chrono>
68

7-
int main() {
9+
int main(int argc, char *argv[]) {
810

9-
int64_t *arr = fill_array_rand_seq(10000);
10-
int arr_size = 10000;
11+
int arr_size = atoi(argv[1]);
12+
int iters = atoi(argv[2]);
1113

12-
int64_t *out = insertionsort_inplace<int64_t>(arr, arr_size);
14+
int64_t *out;
15+
std::chrono::time_point<std::chrono::system_clock> start, end;
16+
std::cout << "Benchmarking insertionsort inplace: " << std::endl;
17+
for (size_t i = 0; i < iters; i++) {
18+
int64_t *arr = fill_array_rand_seq(arr_size);
19+
start = std::chrono::system_clock::now();
20+
out = insertionsort_inplace<int64_t>(arr, arr_size);
21+
end = std::chrono::system_clock::now();
22+
std::chrono::duration<double> elapsed_seconds = end - start;
23+
printf("itertime: %lf\n", elapsed_seconds.count());
24+
}
25+
26+
slice_assert_sorted_2(out, arr_size);
27+
28+
std::cout << std::endl;
29+
std::cout << "Benchmarking quicksort inplace: " << std::endl;
30+
for (size_t i = 0; i < iters; i++) {
31+
int64_t *arr = fill_array_rand_seq(arr_size);
32+
start = std::chrono::system_clock::now();
33+
out = quicksort_inplace<int64_t>(arr, arr_size);
34+
end = std::chrono::system_clock::now();
35+
std::chrono::duration<double> elapsed_seconds = end - start;
36+
printf("itertime: %lf\n", elapsed_seconds.count());
37+
}
1338

1439
slice_assert_sorted_2(out, arr_size);
1540

‎benchrunner/cxx/quicksort.cpp‎

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,144 @@
1+
#include <stdlib.h>
2+
#include <string.h>
3+
#include <stdio.h>
4+
5+
#include "helpers.h"
6+
#include "benchmarks.h"
7+
8+
// -----------------------------------------------------------------------------
9+
10+
// void quicksort_inplace_helper(void *_a, size_t n, size_t es);
11+
12+
template<typename T>
13+
void quicksort_inplace_helper(T *_a, size_t n);
14+
15+
// void *quicksort_glibc(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp)
16+
// {
17+
// // Copy into a fresh array.
18+
// char *cpy = (char *) malloc(total_elems * size);
19+
// if (cpy == NULL) {
20+
// fprintf(stderr, "insertionsort: couldn't allocate");
21+
// exit(1);
22+
// }
23+
// our_memcpy(cpy, (char *) pbase, (size * total_elems));
24+
25+
// // Sort "cpy" in place.
26+
// quicksort_glibc_inplace(cpy, total_elems, size, cmp);
27+
// return cpy;
28+
// }
29+
30+
// void quicksort_glibc_inplace(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp)
31+
// {
32+
// qsort(pbase, total_elems, size, cmp);
33+
// }
34+
35+
// void *quicksort(void *const pbase, size_t total_elems, size_t size)
36+
// {
37+
// // Copy into a fresh array.
38+
// char *cpy = (char *) malloc(total_elems * size);
39+
// if (cpy == NULL) {
40+
// fprintf(stderr, "insertionsort: couldn't allocate");
41+
// exit(1);
42+
// }
43+
// our_memcpy(cpy, (char *) pbase, (size * total_elems));
44+
45+
// // Sort "cpy" in place.
46+
// quicksort_inplace_cmp(cpy, total_elems, size, compare_int64s);
47+
// return cpy;
48+
// }
49+
50+
// void *quicksort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp)
51+
// {
52+
// // Copy into a fresh array.
53+
// char *cpy = (char *) malloc(total_elems * size);
54+
// if (cpy == NULL) {
55+
// fprintf(stderr, "insertionsort: couldn't allocate");
56+
// exit(1);
57+
// }
58+
// our_memcpy(cpy, (char *) pbase, (size * total_elems));
59+
60+
// // Sort "cpy" in place.
61+
// quicksort_inplace_cmp(cpy, total_elems, size, cmp);
62+
// return cpy;
63+
// }
64+
65+
// void quicksort_inplace_cmp(void *_a, size_t n, size_t es, __compar_fn_t cmp)
66+
// {
67+
// char *a = (char *) _a;
68+
// int j;
69+
// char *pi, *pj, *pn;
70+
// if (n <= 1) return;
71+
// pi = a + (rand() % n) * es;
72+
// SWAP(a, pi, es);
73+
// pi = a;
74+
// pj = pn = a + n * es;
75+
// for (;;) {
76+
// do pi += es; while (pi < pn && cmp(pi, a) < 0);
77+
// do pj -= es; while (cmp(pj, a) > 0);
78+
// if (pj < pi) break;
79+
// SWAP(pi, pj, es);
80+
// }
81+
// SWAP(a, pj, es);
82+
// j = (pj - a) / es;
83+
// quicksort_inplace_cmp(a, j, es, cmp);
84+
// quicksort_inplace_cmp(a + (j+1)*es, n-j-1, es, cmp);
85+
// }
86+
87+
// void *quicksort_inplace(void *_a, size_t n, size_t es){
88+
89+
// quicksort_inplace_helper(_a, n, es);
90+
// return _a;
91+
// }
92+
93+
// void quicksort_inplace_helper(void *_a, size_t n, size_t es)
94+
// {
95+
// char *a = (char *) _a;
96+
// int j;
97+
// char *pi, *pj, *pn;
98+
// if (n <= 1) return;
99+
// pi = a + (rand() % n) * es;
100+
// SWAP(a, pi, es);
101+
// pi = a;
102+
// pj = pn = a + n * es;
103+
// for (;;) {
104+
// do pi += es; while (pi < pn && compare_int64s(pi, a) < 0);
105+
// do pj -= es; while (compare_int64s(pj, a) > 0);
106+
// if (pj < pi) break;
107+
// SWAP(pi, pj, es);
108+
// }
109+
// SWAP(a, pj, es);
110+
// j = (pj - a) / es;
111+
// quicksort_inplace(a, j, es);
112+
// quicksort_inplace(a + (j+1)*es, n-j-1, es);
113+
// }
114+
115+
116+
template<typename T>
117+
T *quicksort_inplace(T *_a, size_t n){
118+
119+
quicksort_inplace_helper(_a, n);
120+
return _a;
121+
}
122+
123+
template<typename T>
124+
void quicksort_inplace_helper(T *_a, size_t n)
125+
{
126+
T *a = (T *) _a;
127+
int j;
128+
int pi, pj, pn;
129+
if (n <= 1) return;
130+
pi = (rand() % n);
131+
SWAP2(a, 0, pi);
132+
pi = 0;
133+
pj = pn = n;
134+
for (;;) {
135+
do {pi++;} while (pi < pn && a[pi] < a[0]);
136+
do {pj--;} while (a[pj] > a[0]);
137+
if (pj < pi) break;
138+
SWAP2(a, pi, pj);
139+
}
140+
SWAP2(a, 0, pj);
141+
j = pj;
142+
quicksort_inplace_helper(a, j);
143+
quicksort_inplace_helper(&a[j+1], n-j-1);
144+
}

0 commit comments

Comments
 (0)