Skip to content

Commit 242ecce

Browse files
vidsinghalvidsinghal
committed
remove file
1 parent b52407a commit 242ecce

File tree

1 file changed

+226
-0
lines changed

1 file changed

+226
-0
lines changed

‎benchrunner/cxx/mergesort.cpp‎

Lines changed: 226 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,226 @@
1+
#include "mergesort_common.h"
2+
3+
// -----------------------------------------------------------------------------
4+
5+
// // Whether this mergesort should actually be cilksort.
6+
// static bool CILKSORT = false;
7+
8+
// // Sequential cilksort.
9+
// void *cilksort(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp)
10+
// {
11+
// CILKSORT = true;
12+
// void *sorted = smergesort_cmp(pbase, total_elems, size, cmp);
13+
// CILKSORT = false;
14+
// return sorted;
15+
// }
16+
17+
// // Sequential mergesort.
18+
// void *smergesort(void *const pbase, size_t total_elems, size_t size)
19+
// {
20+
// // Copy into a fresh array.
21+
// char *cpy = (char *) malloc(total_elems * size);
22+
// if (cpy == NULL) {
23+
// fprintf(stderr, "mergesort: couldn't allocate");
24+
// exit(1);
25+
// }
26+
// our_memcpy(cpy, (char *) pbase, (size * total_elems));
27+
28+
// // Temporary buffer.
29+
// char *tmp = (char *) malloc(total_elems * size);
30+
// if (tmp == NULL) {
31+
// fprintf(stderr, "mergesort: couldn't allocate");
32+
// exit(1);
33+
// }
34+
35+
// slice_t cpy_sl = (slice_t) {cpy, total_elems, size};
36+
// slice_t tmp_sl = (slice_t) {tmp, total_elems, size};
37+
38+
// writesort1(cpy_sl, tmp_sl, compare_int64s);
39+
40+
// return cpy;
41+
// }
42+
43+
// // Sequential mergesort.
44+
// void *smergesort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp)
45+
// {
46+
// // Copy into a fresh array.
47+
// char *cpy = (char *) malloc(total_elems * size);
48+
// if (cpy == NULL) {
49+
// fprintf(stderr, "mergesort: couldn't allocate");
50+
// exit(1);
51+
// }
52+
// our_memcpy(cpy, (char *) pbase, (size * total_elems));
53+
54+
// // Temporary buffer.
55+
// char *tmp = (char *) malloc(total_elems * size);
56+
// if (tmp == NULL) {
57+
// fprintf(stderr, "mergesort: couldn't allocate");
58+
// exit(1);
59+
// }
60+
61+
// slice_t cpy_sl = (slice_t) {cpy, total_elems, size};
62+
// slice_t tmp_sl = (slice_t) {tmp, total_elems, size};
63+
64+
// writesort1(cpy_sl, tmp_sl, cmp);
65+
66+
// return cpy;
67+
// }
68+
69+
// // -----------------------------------------------------------------------------
70+
71+
// // Uses "tmp" to sort "src" in place.
72+
// void writesort1(slice_t src, slice_t tmp, __compar_fn_t cmp)
73+
// {
74+
// size_t len = slice_length(&src);
75+
// if (CILKSORT && (len < INSERTIONSIZE)) {
76+
// // insertionsort_inplace(src.base, src.total_elems, src.elt_size, CMP);
77+
// qsort(src.base, src.total_elems, src.elt_size, cmp);
78+
// // quicksort_inplace(src.base, src.total_elems, src.elt_size, CMP);
79+
// return;
80+
// }
81+
// if (len == 1) {
82+
// return;
83+
// }
84+
// size_t half = len / 2;
85+
// slice_prod_t splitsrc = slice_split_at(&src, half);
86+
// slice_prod_t splittmp = slice_split_at(&tmp, half);
87+
// writesort2(splitsrc.left, splittmp.left, cmp);
88+
// writesort2(splitsrc.right, splittmp.right, cmp);
89+
// merge(splittmp.left, splittmp.right, src, cmp);
90+
// return;
91+
// }
92+
93+
// // Uses "src" to sort "tmp" in place.
94+
// void writesort2(slice_t src, slice_t tmp, __compar_fn_t cmp)
95+
// {
96+
// size_t len = slice_length(&src);
97+
// if (CILKSORT && (len < INSERTIONSIZE)) {
98+
// slice_copy(&src, &tmp);
99+
// // insertionsort_inplace(tmp.base, tmp.total_elems, tmp.elt_size, CMP);
100+
// qsort(tmp.base, tmp.total_elems, tmp.elt_size, cmp);
101+
// // quicksort_inplace(tmp.base, tmp.total_elems, tmp.elt_size, CMP);
102+
// return;
103+
// }
104+
// if (len == 1) {
105+
// slice_copy(&src, &tmp);
106+
// return;
107+
// }
108+
// size_t half = len / 2;
109+
// slice_prod_t splitsrc = slice_split_at(&src, half);
110+
// slice_prod_t splittmp = slice_split_at(&tmp, half);
111+
// writesort1(splitsrc.left, splittmp.left, cmp);
112+
// writesort1(splitsrc.right, splittmp.right, cmp);
113+
// merge(splitsrc.left, splitsrc.right, tmp, cmp);
114+
// return;
115+
// }
116+
117+
// size_t binary_search(slice_t *sl, void *query, __compar_fn_t cmp)
118+
// {
119+
// size_t lo = 0;
120+
// size_t hi = slice_length(sl);
121+
122+
// size_t n, mid;
123+
// void *pivot;
124+
// int tst;
125+
126+
// while (hi > lo) {
127+
// n = hi - lo;
128+
// mid = lo + (n/2);
129+
// pivot = slice_nth(sl, mid);
130+
// tst = (*cmp)(query, pivot);
131+
// if (tst == 0) {
132+
// return mid;
133+
// }
134+
// if (tst < 0) {
135+
// hi = mid;
136+
// } else {
137+
// lo = mid+1;
138+
// }
139+
// }
140+
141+
// return lo;
142+
// }
143+
144+
// void merge(slice_t left, slice_t right, slice_t dst, __compar_fn_t cmp)
145+
// {
146+
// size_t i=0, j=0, k=0;
147+
// size_t n1 = slice_length(&left);
148+
// size_t n2 = slice_length(&right);
149+
150+
// void *elt_l, *elt_r;
151+
152+
// while (i < n1 && j < n2) {
153+
// elt_l = slice_nth(&left, i);
154+
// elt_r = slice_nth(&right, j);
155+
// if ((*cmp)(elt_l, elt_r) <= 0) {
156+
// slice_inplace_update(&dst, k, elt_l);
157+
// i++;
158+
// } else {
159+
// slice_inplace_update(&dst, k, elt_r);
160+
// j++;
161+
// }
162+
// k++;
163+
// }
164+
165+
// // Use slice_copy.
166+
// while (i < n1) {
167+
// elt_l = slice_nth(&left, i);
168+
// slice_inplace_update(&dst, k, elt_l);
169+
// i++;
170+
// k++;
171+
// }
172+
173+
// // Use slice_copy.
174+
// while (j < n2) {
175+
// elt_r = slice_nth(&right, j);
176+
// slice_inplace_update(&dst, k, elt_r);
177+
// j++;
178+
// k++;
179+
// }
180+
181+
// return;
182+
// }
183+
184+
185+
// referenced from here: https://en.wikipedia.org/wiki/Merge_sort
186+
187+
188+
template <typename T>
189+
T *bottomUpMergeSort(T *a, T *b, int n){
190+
191+
for (int width = 1; width < n; width = 2 * width){
192+
193+
for (int i = 0; i < n; i = i + 2 * width){
194+
bottomUpMerge(a, i, std::min(i + width, n), std::min(i + 2 * width, n), b);
195+
}
196+
copyArray(b, a, n);
197+
}
198+
199+
return a;
200+
}
201+
202+
template <typename T>
203+
void bottomUpMerge(T *a, int left, int right, int end, T *b){
204+
205+
int i = left;
206+
int j = right;
207+
208+
for (int k = left; k < end; k++){
209+
if (i < right && (j >= end || a[i] <= a[j])){
210+
b[k] = a[i];
211+
i = i + 1;
212+
}
213+
else{
214+
b[k] = a[j];
215+
j = j + 1;
216+
}
217+
}
218+
}
219+
220+
template <typename T>
221+
void copyArray(T *b, T* a, int n){
222+
int i;
223+
for (i = 0; i < n; i++){
224+
a[i] = b[i];
225+
}
226+
}

0 commit comments

Comments
 (0)