formatting

Author: vidsinghal

benchrunner/cxx/Makefile

@@ -54,6 +54,6 @@ $(OUT): $(OBJFILES)
 	$(CC) $(CFLAGS) -c -o $@ $^
 
 clean:
-	rm -f  $(OUT)
+	rm -f  $(OUT) *.o
 
 .PHONY: clean

benchrunner/cxx/benchmarks.h

@@ -4,29 +4,17 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <iostream>
+#include <chrono>
 
 // Copied from stdlib.h for reference.
 typedef int (*__compar_fn_t) (const void *, const void *);
 
 // Sorting algorithms.
-void *insertionsort_glibc(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void insertionsort_glibc_inplace(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *insertionsort_copy(void *const pbase, size_t total_elems, size_t size);
-void *insertionsort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void insertionsort_inplace_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
 template<typename T> T *insertionsort_inplace(T *pbase, size_t total_elems);
-void *quicksort_glibc(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void quicksort_glibc_inplace(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *quicksort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *quicksort(void *const pbase, size_t total_elems, size_t size);
-void quicksort_inplace_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
 template<typename T> T *quicksort_inplace(T *_a, size_t n);
-void *smergesort(void *const pbase, size_t total_elems, size_t size);
-void *smergesort_cmp(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *mergesort_par(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *cilksort(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
-void *cilksort_par(void *const pbase, size_t total_elems, size_t size, __compar_fn_t cmp);
 template <typename T> T *bottomUpMergeSort(T *a, T *b, int n);
+template <typename T> void bottomUpMerge(T *a, int left, int right, int end, T *b);
+template <typename T> void copyArray(T *b, T* a, int n);
 
 // Relating to C++ templatized versions
 extern "C" {
@@ -36,15 +24,6 @@ extern int64_t *quicksort_cxx_int(int64_t *pbase, size_t total_elems);
 }
 
 // Microbenchmarks.
-int64_t* __attribute__ ((noinline)) fill_array_seq(size_t total_elems, int64_t val);
-int64_t* __attribute__ ((noinline)) fill_array_par(size_t total_elems, int64_t val);
 int64_t* __attribute__ ((noinline)) fill_array_rand_seq(size_t total_elems);
-int64_t* __attribute__ ((noinline)) fill_array_ones_seq(size_t total_elems);
-int64_t __attribute__ ((noinline)) sum_array_seq(size_t total_elems, int64_t *nums);
-int64_t __attribute__ ((noinline)) sum_array_par(size_t total_elems, int64_t *nums);
-void __attribute__ ((noinline)) copy_seq(void *dst, void *src, size_t nbytes);
-void __attribute__ ((noinline)) copy_par(void *dst, void *src, size_t nbytes);
-int64_t fib(int64_t n);
-int64_t fib_par(int64_t n);
 
 #endif

benchrunner/cxx/cbench.h

@@ -10,144 +10,20 @@
 #include <time.h>
 #include <assert.h>
 
-#ifndef HAVE_GLIBC_COMPAR_FN_T
-typedef int (*__compar_fn_t)(const void *, const void *);
-#endif
-
-// -----------------------------------------------------------------------------
-
-static inline int compare_int64s(const void* a, const void* b);
-
-static inline int compare_int64s(const void* a, const void* b)
-{
-    int64_t arg1 = *(const int64_t*)a;
-    int64_t arg2 = *(const int64_t*)b;
-
-    if (arg1 < arg2) return -1;
-    if (arg1 > arg2) return 1;
-    return 0;
-}
-
-
-static inline double difftimespecs(struct timespec* t0, struct timespec* t1)
-{
-    return (double)(t1->tv_sec - t0->tv_sec)
-            + ((double)(t1->tv_nsec - t0->tv_nsec) / 1000000000.0);
-}
-
-static inline bool prefix(const char *pre, const char *str)
-{
-    return strncmp(pre, str, strlen(pre)) == 0;
-}
-
-static inline void our_memcpy(void *dst, void *src, size_t nbytes)
-{
-    memcpy(dst, src, nbytes);
-}
-
-// Taken from glibc.
-static inline void SWAP(void *a, void *b, size_t elt_size)
-{
-    size_t __size = elt_size;
-    char *__a = (char*)a;
-    char *__b = (char*)b;
-    do {
-        char __tmp = * __a;
-        *__a++ = *__b;
-        *__b++ = __tmp;
-    } while (--__size > 0);
-}
-
-template<typename T>
-static inline void SWAP2(T *a, int i, int j)
-{
-    T _tmp = a[i];
-    a[i] = a[j];
-    a[j] = _tmp;
-}
-
-// -----------------------------------------------------------------------------
-
-typedef struct slice_t_ {
-    void *base;
-    size_t total_elems;
-    size_t elt_size;
-} slice_t;
-
-typedef struct slice_prod_t_ {
-    slice_t left;
-    slice_t right;
-} slice_prod_t;
-
-static inline size_t slice_length(const slice_t *sl)
+int64_t* __attribute__ ((noinline)) fill_array_rand_seq(size_t total_elems)
 {
-    return sl->total_elems;
-}
-
-static inline void *slice_nth(const slice_t *sl, size_t n)
-{
-    return (char*) sl->base + (n * sl->elt_size);
-}
-
-static inline void slice_copy(slice_t *src, slice_t *dst)
-{
-    our_memcpy(dst->base, src->base, (src->total_elems * src->elt_size));
-    return;
-}
-
-static inline void slice_inplace_update(slice_t *sl, size_t i, void* elt) {
-    void* dst = slice_nth(sl, i);
-    our_memcpy(dst, elt, sl->elt_size);
-}
-
-// "idx" is the start index, "elems" is the length of the new slice.
-static inline slice_t slice_narrow(const slice_t *sl, size_t idx, size_t elems)
-{
-    return (slice_t) { (char*) sl->base + (sl->elt_size * idx), elems, sl->elt_size };
-}
-
-static inline slice_prod_t slice_split_at(const slice_t *sl, size_t idx)
-{
-    /*
-    slice_t left = (slice_t) { sl->base, idx, sl->elt_size };
-    slice_t right = (slice_t) { (char*) sl->base + (sl->elt_size * idx),
-                                (sl->total_elems - idx),
-                                sl->elt_size };
-    */
-    size_t len = slice_length(sl);
-    slice_t left = slice_narrow(sl, 0, idx);
-    slice_t right = slice_narrow(sl, idx, len-idx);
-    return (slice_prod_t) { left, right };
-}
-
-static inline void slice_print(const slice_t *sl)
-{
-    printf("[");
-    char *elt;
-    for (size_t i = 0; i < sl->total_elems; i++) {
-        elt = (char*) sl->base + (i * sl->elt_size);
-        if (sl->elt_size == sizeof(int64_t)) {
-            printf("%ld, ", *(int64_t*) elt);
-        } else {
-            printf("%p, ", (void*) elt);
-        }
+    void *nums;
+    nums = (int64_t*) malloc(total_elems * sizeof(int64_t));
+    if (nums == NULL) {
+        fprintf(stderr, "Couldn't allocate memory for output array.\n");
+        return NULL;
     }
-    printf("]\n");
-}
-
-static inline void slice_assert_sorted(__compar_fn_t cmp, const slice_t *sl)
-{
-    size_t len = slice_length(sl);
-    void *a, *b;
-    for (size_t i = 0; i < len-1; i++) {
-        a = slice_nth(sl, i);
-        b = slice_nth(sl, i+1);
-        if ((*cmp)(a,b) > 0) {
-            fprintf(stderr, "Elements at %zu and %zu are not sorted.", i, i+1);
-            exit(1);
-        }
+    int64_t *elt = (int64_t *) nums;
+    for (uint64_t i = 0; i <= total_elems-1; i++) {
+        elt = (int64_t*) nums + i;
+        *elt = rand();
     }
-    printf("Sorted: OK\n");
+    return (int64_t *) nums;
 }
 
 static inline void slice_assert_sorted_2(int64_t *arr, int size)