formatting

Author: vidsinghal

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,32 @@ 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,38 @@ executable benchrunner
     ghc-options:        -Wall -Wcompat
                         -threaded -rtsopts
                         -fdefer-typed-holes
-                        -O2
+                        -O2 -optl -lstdc++ -optl -lgcc_s
+
+
+
 
     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
+
+	if impl(ghc >= 9.4)
+		build-depends:      system-cxx-std-lib
+	else
+    		if os(windows)
+			extra-libraries:  stdc++
+		if os(linux)
+			extra-libraries:  stdc++
+    		if os(darwin)
+      			extra-libraries:  stdc++
+
+
     -- DNDEBUG disables asserts in cbits/
     cc-options:        -std=c11 -O3 -DNDEBUG=1
                        -fno-strict-aliasing
                        -Werror=undef
+
+    cpp-options: -std=c++11 -O3

benchrunner/cxx/benchmarks.h

@@ -29,9 +29,9 @@ void *cilksort_par(void *const pbase, size_t total_elems, size_t size, __compar_
 template <typename T> T *bottomUpMergeSort(T *a, T *b, int n);
 
 // Relating to C++ templatized versions
-int64_t *bottom_up_merge_sort_int(int64_t *pbase, size_t total_elems);
-int64_t *insertionsort_int(int64_t *pbase, size_t total_elems);
-int64_t *quicksort_int(int64_t *pbase, size_t total_elems);
+int64_t *bottom_up_merge_sort_cxx_int(int64_t *pbase, size_t total_elems);
+int64_t *insertionsort_cxx_int(int64_t *pbase, size_t total_elems);
+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);

benchrunner/cxx/insertionsort_int_wrapper.cpp

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

benchrunner/cxx/mergesort_int_wrapper.cpp

@@ -2,7 +2,7 @@
 #include "mergesort.cpp"
 
 
-int64_t *bottom_up_merge_sort_int(int64_t *pbase, size_t total_elems){
+int64_t *bottom_up_merge_sort_cxx_int(int64_t *pbase, size_t total_elems){
 
     int64_t *copy_pbase = new int64_t[total_elems];
     copyArray<int64_t>(pbase, copy_pbase, total_elems);

benchrunner/cxx/quicksort_int_wrapper.cpp

@@ -1,6 +1,6 @@
 #include "benchmarks.h"
 #include "quicksort.cpp"
 
-int64_t *quicksort_int(int64_t *pbase, size_t total_elems){
+int64_t *quicksort_cxx_int(int64_t *pbase, size_t total_elems){
     return quicksort_inplace<int64_t>(pbase, total_elems);
 }