Merge branch 'main' into fix-failing-array-tests

Author: Mikah-Kainen

benchrunner/Benchrunner.hs

@@ -218,6 +218,12 @@ dobench bench parorseq mb_size iters = do
         unless (isSorted (res0)) (error $ show bench ++ ": result not sorted.")
         putStrLn "Sorted: OK"
         pure (length arr, length res0, tmed0, tall0)
+      CxxSort alg -> do
+        arr <- getInputAsList alg mb_size
+        (res0, tmed0, tall0) <- M.benchAndRunCxxSorts alg arr iters
+        unless (isSorted (res0)) (error $ show bench ++ ": result not sorted.")
+        putStrLn "Sorted: OK"
+        pure (length arr, length res0, tmed0, tall0)
       _ -> error "dobench: case not implemented!"
 
 {-

benchrunner/ForeignFunctionImports.hs

@@ -1,4 +1,4 @@
-module ForeignFunctionImports (c_insertionsort, c_mergesort, c_quicksort, SortFn) where
+module ForeignFunctionImports (c_insertionsort, c_mergesort, c_quicksort, cxx_int_insertionsort, cxx_int_mergesort, cxx_int_quicksort, SortFn, SortFnCxx) where
 
 import Foreign as F
 import Foreign.C.Types as CTypes
@@ -9,3 +9,8 @@ type SortFn = Ptr Int64 -> CTypes.CSize -> CTypes.CSize -> IO (Ptr Int64)
 foreign import ccall "insertionsort_inplace" c_insertionsort :: SortFn
 foreign import ccall "smergesort" c_mergesort :: SortFn
 foreign import ccall "quicksort_inplace" c_quicksort :: SortFn
+
+type SortFnCxx = Ptr Int64 -> CTypes.CSize -> IO (Ptr Int64)
+foreign import ccall "insertionsort_cxx_int" cxx_int_insertionsort :: SortFnCxx
+foreign import ccall "bottom_up_merge_sort_cxx_int" cxx_int_mergesort :: SortFnCxx
+foreign import ccall "quicksort_cxx_int" cxx_int_quicksort :: SortFnCxx

benchrunner/Measure.hs

@@ -1,4 +1,4 @@
-module Measure (benchAndRunCSorts, benchAndRunDataVecSorts, benchOnArrays, bench, benchPar, dotrialIO, benchIO, benchParIO) where
+module Measure (benchAndRunCSorts, benchAndRunCxxSorts, benchAndRunDataVecSorts, benchOnArrays, bench, benchPar, dotrialIO, benchIO, benchParIO) where
 
 import Control.Exception (evaluate)
 import Control.Monad.Par hiding (runParIO)
@@ -157,6 +157,13 @@ sortFnC alg = case alg of
                     Quicksort -> FFI.c_quicksort
                     _ -> error "sortFnC: Csort not implemented!"
 
+sortFnCxx :: SortAlgo -> FFI.SortFnCxx
+sortFnCxx alg = case alg of
+                    Insertionsort -> FFI.cxx_int_insertionsort
+                    Mergesort -> FFI.cxx_int_mergesort
+                    Quicksort -> FFI.cxx_int_quicksort
+                    _ -> error "sortFnCxx: Csort not implemented!"
+
 -- return type : IO ([Int64], Double, Double)
 -- [Int64]: sorted output array from the last iteration that was run
 -- Double: median runtime from the iterations that were run (selftimed)
@@ -184,3 +191,31 @@ benchAndRunCSorts salg arr iters = do
         putStrLn ("iter time: " ++ show delt)
         !sortedArr <- peekArray arrLength (castPtr sortedPtr :: Ptr Int64)
         return $! (sortedArr, delt)
+
+-- return type : IO ([Int64], Double, Double)
+-- [Int64]: sorted output array from the last iteration that was run
+-- Double: median runtime from the iterations that were run (selftimed)
+-- Double: Total time taken to run all the iterations (batchtime)
+benchAndRunCxxSorts :: SortAlgo -> [Int64] -> Int -> IO ([Int64], Double, Double)
+benchAndRunCxxSorts salg arr iters = do
+  !tups <- mapM (\_ -> do
+                       !ptr <- newArray arr
+                       res <- dotrialCxx salg (length arr) ptr
+                       pure res
+                ) [1..iters]
+  let (results, times) = unzip tups
+  -- print times
+  let  selftimed = median times
+       batchtime = sum times
+  return $! (last results, selftimed, batchtime)
+  where
+    dotrialCxx alg arrLength ptr = do
+        performMajorGC
+        let fn = sortFnCxx alg
+        t1 <- getCurrentTime
+        !sortedPtr <- fn ptr (fromIntegral arrLength)
+        t2 <- getCurrentTime
+        let delt = fromRational (toRational (diffUTCTime t2 t1))
+        putStrLn ("iter time: " ++ show delt)
+        !sortedArr <- peekArray arrLength (castPtr sortedPtr :: Ptr Int64)
+        return $! (sortedArr, delt)

benchrunner/Types.hs

@@ -23,6 +23,7 @@ data Benchmark
   | OurSort SortAlgo
   | VectorSort SortAlgo
   | CSort SortAlgo
+  | CxxSort SortAlgo
   deriving (Eq, Show, Read)
 
 data ParOrSeq = Seq | Par | ParM

benchrunner/benchrunner.cabal

@@ -1,5 +1,4 @@
-cabal-version:      >=1.10
-
+cabal-version:      2.2
 name:               benchrunner
 version:            0.1
 build-type:         Simple
@@ -33,14 +32,28 @@ executable benchrunner
     ghc-options:        -Wall -Wcompat
                         -threaded -rtsopts
                         -fdefer-typed-holes
-                        -O2
+                        -O2 -optl -optl-lstdc++
+
+    extra-libraries: stdc++
 
     c-sources:
                       csorts/insertionsort.c
                       csorts/mergesort.c
                       csorts/quicksort.c
 
+    cxx-sources:
+                      cxx/insertionsort.cpp
+                      cxx/mergesort.cpp
+                      cxx/quicksort.cpp
+                      cxx/insertionsort_int_wrapper.cpp
+                      cxx/mergesort_int_wrapper.cpp
+                      cxx/quicksort_int_wrapper.cpp
+
+    build-depends:      system-cxx-std-lib
+
     -- DNDEBUG disables asserts in cbits/
     cc-options:        -std=c11 -O3 -DNDEBUG=1
                        -fno-strict-aliasing
                        -Werror=undef
+
+    cpp-options: -std=c++11 -O3 -fno-strict-aliasing

benchrunner/cxx/Makefile

@@ -0,0 +1,59 @@
+CFILES   = $(wildcard *.c) $(wildcard *.cpp)
+OBJFILES = $(CFILES:.cpp=.o)
+OUT      = cbench.exe
+
+USECLANG    := 0
+DEBUG       := 0
+CILK        := 0
+
+ifeq ($(CILK), 1)
+  ifeq ($(USECLANG), 0)
+    $(error cilk can only be used with an opencilk compiler!)
+  endif
+endif
+
+OpenCILK_CLANG       := clang-16
+OpenCILK_CLANG_FLAGS := -std=gnu11 -DCILK -fopencilk -fPIC
+CLANG       := clang++
+CLANG_FLAGS := -std=c++11 -lm -fPIC
+GCC         := g++
+GCC_FLAGS   := -std=c++11 -lm -fPIC
+
+CC     := $(GCC)
+CFLAGS := $(GCC_FLAGS)
+CDEBUG := -DCBENCH_DEBUG -O0 -g
+
+CFLAGS += -Wall -Wextra -Wpedantic -flto
+
+ifeq ($(USECLANG), 1)
+  CC     = $(CLANG)
+  CFLAGS = $(CLANG_FLAGS)
+  LFLAGS := -fuse-ld=lld
+endif
+
+ifeq ($(CILK), 1)
+  ifeq ($(USECLANG), 1)
+    CC     = $(OpenCILK_CLANG)
+    CFLAGS = $(OpenCILK_CLANG_FLAGS)
+    LFLAGS := -fuse-ld=lld
+  endif
+endif
+
+ifeq ($(DEBUG), 1)
+  CFLAGS += $(CDEBUG)
+else
+  CFLAGS += -O3
+endif
+
+all: $(OUT)
+
+$(OUT): $(OBJFILES)
+	$(CC) $(CFLAGS) $(LFLAGS) -o $@ $^
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $^
+
+clean:
+	rm -f  $(OUT) *.o
+
+.PHONY: clean

benchrunner/cxx/benchmarks.h

@@ -0,0 +1,29 @@
+#ifndef _BENCHMARKS_H
+#define _BENCHMARKS_H
+
+#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.
+template<typename T> T *insertionsort_inplace(T *pbase, size_t total_elems);
+template<typename T> T *quicksort_inplace(T *_a, size_t n);
+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" {
+    extern int64_t *bottom_up_merge_sort_cxx_int(int64_t *pbase, size_t total_elems);
+    extern int64_t *insertionsort_cxx_int(int64_t *pbase, size_t total_elems);
+    extern int64_t *quicksort_cxx_int(int64_t *pbase, size_t total_elems);
+}
+
+// Microbenchmarks.
+int64_t* __attribute__ ((noinline)) fill_array_rand_seq(size_t total_elems);
+
+#endif

benchrunner/cxx/helpers.h

@@ -0,0 +1,44 @@
+#ifndef _HELPERS_H
+#define _HELPERS_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
+
+int64_t* __attribute__ ((noinline)) fill_array_rand_seq(size_t total_elems)
+{
+    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;
+    }
+    int64_t *elt = (int64_t *) nums;
+    for (uint64_t i = 0; i <= total_elems-1; i++) {
+        elt = (int64_t*) nums + i;
+        *elt = rand();
+    }
+    return (int64_t *) nums;
+}
+
+static inline void slice_assert_sorted(int64_t *arr, int size)
+{
+    size_t len = size;
+    int64_t a, b;
+    for (size_t i = 0; i < len-1; i++) {
+        a = arr[i];
+        b = arr[i+1];
+        if (a > b) {
+            fprintf(stderr, "Elements at %zu and %zu are not sorted.", i, i+1);
+            exit(1);
+        }
+    }
+    printf("Sorted: OK\n");
+}
+
+#endif

benchrunner/cxx/insertionsort.cpp

@@ -0,0 +1,32 @@
+#include "benchmarks.h"
+
+// -----------------------------------------------------------------------------
+//     i ← 1
+//     while i < n
+//         temp ← array[i]
+//         j ← i
+//         while j > 0 and array[j - 1] > temp
+//             array[j] ← array[j - 1]
+//             j ← j - 1
+//         end while
+//         array[j] ← temp
+//         i ← i + 1
+//     end while
+
+template<typename T>
+T *insertionsort_inplace(T *pbase, size_t total_elems)
+{
+    int i = 0;
+    while (i < total_elems){
+        T temp = pbase[i];
+        int j = i;
+        while(j > 0 && pbase[j - 1] > temp){
+            pbase[j] = pbase[j-1];
+            j = j - 1;
+        }
+        pbase[j] = temp;
+        i = i + 1;
+    }
+
+    return pbase;
+}

benchrunner/cxx/insertionsort_int_wrapper.cpp

@@ -0,0 +1,8 @@
+#include "benchmarks.h"
+#include "insertionsort.cpp"
+
+extern "C" {
+    extern int64_t *insertionsort_cxx_int(int64_t *pbase, size_t total_elems){
+        return insertionsort_inplace<int64_t>(pbase, total_elems);
+    }
+}