[1/16] SBM: The Haskell and C benchmarks

View: New views

1 Messages — Rating Filter: Alert me

[1/16] SBM: The Haskell and C benchmarks

by Peter Firefly Brodersen Lund :: Rate this Message:

Reply to Author | View Threaded | Show Only this Message

Here are the 48 Haskell and C benchmarks.

Don Stewart contributed three (although I had to fight a bit to make one of
them compile).
Jules Bean (quicksilver) contributed one.
Bertram Felgenhauer (int-e) contributed three (in the form of a single file,
which I untangled).
Spencer Jannsen (sjannsen) contributed one.

wli (William Lee Irwin III) inspired me to add the getwchar benchmarks.

I used the following shell code to gather all the benchmarks:

(for F in hs/*.hs c/*.c; \
do echo "------------------------------"; \
echo "$F:"; \
echo ; \
cat "$F"; \
done; \
echo "==============================" \
) > xx.txt

They are not in the same order as in the Makefile or in the reports,
unfortunately.

-Peter

------------------------------
hs/byte-bs----acc.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString as B

cnt :: Int -> B.ByteString -> Int
cnt !acc !bs = if B.null bs
then acc
else cnt (acc+1) (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)
------------------------------
hs/byte-bs----foldlx.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString as B

cnt :: B.ByteString -> Int
cnt !bs = B.foldl' (\sum _ -> sum+1) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/byte-bs----foldrx.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString as B

cnt :: B.ByteString -> Int
cnt !bs = B.foldr' (\_ sum -> sum+1) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/byte-bsl---acc.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy as B

cnt :: Int -> B.ByteString -> Int
cnt !acc !bs = if B.null bs
then acc
else cnt (acc+1) (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)
------------------------------
hs/byte-xxxxx-acc-1.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: Int -> String -> Int
cnt !acc bs = if null bs
then acc
else cnt (acc+1) (tail bs)

main = do s <- getContents
print (cnt 0 s)
------------------------------
hs/byte-xxxxx-acc-2.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: Int -> String -> Int
cnt !acc !bs = if null bs
then acc
else cnt (acc+1) (tail bs)

main = do s <- getContents
print (cnt 0 s)
------------------------------
hs/byte-xxxxx-foldl.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt !bs = foldl (\sum _ -> sum+1) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/byte-xxxxx-foldr-1.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt bs = foldr (\_ sum -> sum+1) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/byte-xxxxx-foldr-2.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt !bs = foldr (\_ sum -> sum+1) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/space-bs-c8-acc-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Char8 as B

cnt :: Int -> B.ByteString -> Int
cnt !acc bs = if B.null bs
then acc
else cnt (if B.head bs == ' ' then acc+1 else acc) (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)
------------------------------
hs/space-bs-c8-count.hs:

-- Don Stewart
import qualified Data.ByteString.Char8 as B
main = print . B.count ' ' =<< B.getContents

------------------------------
hs/space-bs-c8-foldlx-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Char8 as B

cnt :: B.ByteString -> Int
cnt bs = B.foldl' (\sum c -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bs-c8-foldlx-2.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Char8 as B

main = do s <- B.getContents
print $ B.foldl' (\v c -> if c == ' ' then v+1 else v :: Int) 0 s

------------------------------
hs/space-bs-c8-foldrx.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Char8 as B

cnt :: B.ByteString -> Int
cnt bs = B.foldr' (\c sum -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bs-c8-lenfil.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Char8 as B

cnt :: B.ByteString -> Int
cnt bs = B.length (B.filter (== ' ') bs)

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-acc-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: Int -> B.ByteString -> Int
cnt !acc bs = if B.null bs
then acc
else cnt (if B.head bs == ' ' then acc+1 else acc) (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)
------------------------------
hs/space-bslc8-acc-2.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: Int -> B.ByteString -> Int
cnt !acc !bs = if B.null bs
then acc
else cnt (if B.head bs == ' ' then acc+1 else acc) (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)
------------------------------
hs/space-bslc8-acc-3.hs:

{-# LANGUAGE BangPatterns #-}
-- this version by quicksilver

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: Int -> B.ByteString -> Int
cnt !acc bs | B.null bs = acc
| B.head bs == ' ' = cnt (acc+1) (B.tail bs)
| otherwise = cnt acc (B.tail bs)

main = do s <- B.getContents
print (cnt 0 s)

------------------------------
hs/space-bslc8-chunk-1.hs:

{-# LANGUAGE BangPatterns #-}
-- this version by int-e

import qualified Data.ByteString.Lazy.Char8 as B
import qualified Data.ByteString.Char8 as BS
import Data.List (foldl')

cntS :: Int -> BS.ByteString -> Int
cntS !acc !bs = case BS.uncons bs of
Nothing -> acc
Just (hd, tl) | hd == ' ' -> cntS (acc+1) tl
| otherwise -> cntS acc tl

cnt :: Int -> B.ByteString -> Int
cnt acc bs = foldl' cntS acc (B.toChunks bs)

main = do s <- B.getContents
print $ cnt 0 s

------------------------------
hs/space-bslc8-chunk-2.hs:

{-# LANGUAGE BangPatterns #-}
-- this version by int-e

import qualified Data.ByteString.Lazy.Char8 as B
import qualified Data.ByteString.Char8 as BS
import Data.List (foldl')

cntS' :: Int -> BS.ByteString -> Int
cntS' !acc !bs | BS.null bs = acc
| BS.head bs == ' ' = cntS' (acc+1) (BS.tail bs)
| otherwise = cntS' acc (BS.tail bs)

cnt :: Int -> B.ByteString -> Int
cnt acc bs = foldl' cntS' acc (B.toChunks bs)

main = do s <- B.getContents
print $ cnt 0 s

------------------------------
hs/space-bslc8-chunk-3.hs:

{-# LANGUAGE BangPatterns #-}
-- this version by int-e

import qualified Data.ByteString.Lazy.Char8 as B
import qualified Data.ByteString.Char8 as BS
import Data.List (foldl')

cntS'' :: Int -> BS.ByteString -> Int
cntS'' !acc !bs = BS.foldl' (\v c -> if c == ' ' then v+1 else v) acc bs

cnt :: Int -> B.ByteString -> Int
cnt acc bs = foldl' cntS'' acc (B.toChunks bs)

main = do s <- B.getContents
print $ cnt 0 s

------------------------------
hs/space-bslc8-chunk-4.hs:

{-# LANGUAGE BangPatterns #-}

-- Don Stewart
import qualified Data.ByteString.Lazy.Char8 as BLC8
import qualified Data.ByteString.Lazy.Internal as BLI
import qualified Data.ByteString as B
import qualified Data.ByteString.Unsafe as BU
import qualified Data.ByteString.Internal as BI

cnt :: Int -> BLC8.ByteString -> Int
cnt n BLI.Empty = n
cnt n (BLI.Chunk x xs) = cnt (n + cnt_strict 0 x) xs -- process lazy spine
where -- now we can process a chunk without checking for Empty
cnt_strict !i !s -- then strict chunk
| B.null s = i
| c == ' ' = cnt_strict (i+1) t
| otherwise = cnt_strict i t
where
(c,t) = (BI.w2c (BU.unsafeHead s), BU.unsafeTail s) -- no bounds check

main = do s <- BLC8.getContents; print (cnt 0 s)

------------------------------
hs/space-bslc8-count.hs:

-- Don Stewart
import qualified Data.ByteString.Lazy.Char8 as B
main = print . B.count ' ' =<< B.getContents

------------------------------
hs/space-bslc8-foldl.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: B.ByteString -> Int
cnt !bs = B.foldl (\sum c -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-foldlx-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: B.ByteString -> Int
cnt bs = B.foldl' (\sum c -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-foldlx-2.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: B.ByteString -> Int
cnt !bs = B.foldl' (\sum c -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-foldr-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: B.ByteString -> Int
cnt bs = B.foldr (\c sum -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-foldr-2.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B

cnt :: B.ByteString -> Int
cnt !bs = B.foldr (\c sum -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-lenfil-1.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B
import GHC.Int (Int64)

-- note that D.BS.Lazy.Char8.length is ByteString -> Int64
-- D.BS.C8.length is ByteString -> Int
cnt :: B.ByteString -> Int64
cnt bs = B.length (B.filter (== ' ') bs)

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bslc8-lenfil-2.hs:

{-# LANGUAGE BangPatterns #-}

import qualified Data.ByteString.Lazy.Char8 as B
import GHC.Int (Int64)

-- note that D.BS.Lazy.Char8.length is ByteString -> Int64
-- D.BS.C8.length is ByteString -> Int
cnt :: B.ByteString -> Int64
cnt !bs = B.length (B.filter (== ' ') bs)

main = do s <- B.getContents
print (cnt s)
------------------------------
hs/space-bsl---foldlx.hs:

{-# LANGUAGE BangPatterns #-}
-- this version by sjannsen

import Data.ByteString.Lazy as B

cnt :: B.ByteString -> Int
cnt = B.foldl' f 0
where
f !n 32 = n+1
f !n _ = n

main = do
s <- B.getContents
print $ cnt s

------------------------------
hs/space-xxxxx-acc-1.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: Int -> String -> Int
cnt !acc bs = if null bs
then acc
else cnt (if head bs == ' ' then acc+1 else acc) (tail bs)

main = do s <- getContents
print (cnt 0 s)
------------------------------
hs/space-xxxxx-acc-2.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: Int -> String -> Int
cnt !acc !bs = if null bs
then acc
else cnt (if head bs == ' ' then acc+1 else acc) (tail bs)

main = do s <- getContents
print (cnt 0 s)
------------------------------
hs/space-xxxxx-foldl.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt bs = foldl (\sum c -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/space-xxxxx-foldr-1.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt bs = foldr (\c sum -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/space-xxxxx-foldr-2.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt !bs = foldr (\c sum -> if c == ' ' then sum+1 else sum) 0 bs

main = do s <- getContents
print (cnt s)
------------------------------
hs/space-xxxxx-lenfil.hs:

{-# LANGUAGE BangPatterns #-}

cnt :: String -> Int
cnt bs = length (filter (== ' ') bs)

main = do s <- getContents
print (cnt s)
------------------------------
c/byte-4k.c:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int Main_cnt()
{
int cnt = 0;
ssize_t sze;
char buf[4*1024];

do {
again:
sze = read(fileno(stdin), buf, sizeof(buf));
if (sze < 0) {
switch (errno) {
case EAGAIN: goto again;
default:
perror("read() failed\n");
exit(1);
}
}

cnt += sze;
} while (sze != 0);

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/byte-getchar.c:

#include <stdio.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
int c;

while ((c = getchar()) != EOF)
cnt++;

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/byte-getchar-u.c:

#include <stdio.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
int c;

while ((c = getchar_unlocked()) != EOF)
cnt++;

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-32k-8.c:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int Main_cnt()
{
int cnt = 0;
ssize_t sze, left;
char buf[32760];
char *p;

printf("using a buffer of %g KB\n", sizeof(buf) / 1024.0);

do {
again:
sze = read(fileno(stdin), buf, sizeof(buf));
if (sze < 0) {
switch (errno) {
case EAGAIN: goto again;
default:
perror("read() failed\n");
exit(1);
}
}

for (p = buf, left=sze; left > 0; left--)
if (*p++ == ' ')
cnt++;
} while (sze != 0);

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-32k.c:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int Main_cnt()
{
int cnt = 0;
ssize_t sze, left;
char buf[32*1024];
char *p;

printf("using a buffer of %g KB\n", sizeof(buf) / 1024.0);

do {
again:
sze = read(fileno(stdin), buf, sizeof(buf));
if (sze < 0) {
switch (errno) {
case EAGAIN: goto again;
default:
perror("read() failed\n");
exit(1);
}
}

for (p = buf, left=sze; left > 0; left--)
if (*p++ == ' ')
cnt++;
} while (sze != 0);

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-4k.c:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

int Main_cnt()
{
int cnt = 0;
ssize_t sze, left;
char buf[4*1024];
char *p;

printf("using a buffer of %g KB\n", sizeof(buf) / 1024.0);

do {
again:
sze = read(fileno(stdin), buf, sizeof(buf));
if (sze < 0) {
switch (errno) {
case EAGAIN: goto again;
default:
perror("read() failed\n");
exit(1);
}
}

for (p = buf, left=sze; left > 0; left--)
if (*p++ == ' ')
cnt++;
} while (sze != 0);

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-getchar.c:

#include <stdio.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
int c;

while ((c = getchar()) != EOF)
if (c == ' ')
cnt++;
return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-getchar-u.c:

#include <stdio.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
int c;

while ((c = getchar_unlocked()) != EOF)
if (c == ' ')
cnt++;
return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-getwchar.c:

#include <stdio.h>
#include <wchar.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
wint_t c;

while ((c = getwchar()) != WEOF)
if (c == ' ')
cnt++;
return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-getwchar-u.c:

#define _GNU_SOURCE
#include <stdio.h>
#include <wchar.h>
#include <stdlib.h>

int Main_cnt()
{
int cnt = 0;
wint_t c;

while ((c = getwchar_unlocked()) != WEOF)
if (c == ' ')
cnt++;
return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

------------------------------
c/space-megabuf.c:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>

int isfile(int handle)
{
struct stat buf;

if (fstat(handle, &buf) == -1) {
perror("fstat(stdin)\n");
exit(1);
}

return S_ISREG(buf.st_mode);
}

ssize_t getbufsize()
{
if (isfile(fileno(stdin))) {
off_t x;

x = lseek(fileno(stdin), 0, SEEK_END);
if (x == -1) {
perror("lseek(... SEEK_END)\n");
exit(1);
}
if (lseek(fileno(stdin), 0, SEEK_SET) == -1) {
perror("lseek(... SEEK_SET)\n");
exit(1);
}
if (x > 1*1024*1024*1024LL) {
x = 1024*1024*1024LL;
}
return x; /* file size for files */
} else {
return 10*1024*1024; /* 10M for non-files */
}
}

int Main_cnt()
{
int cnt = 0, reads=0, retries=0;
ssize_t sze, left, bufsize;
char *buf;
char *p;

bufsize = getbufsize();
printf("using a buffer of %g MB\n", bufsize / (1024*1024.0));

buf = malloc(bufsize);
if (!buf) {
fprintf(stderr, "couldn't allocate %lld bytes\n",
(long long) bufsize);
}

do {
again:
sze = read(fileno(stdin), buf, bufsize);
if (sze < 0) {
switch (errno) {
case EAGAIN: retries++; goto again;
default:
perror("read() failed\n");
exit(1);
}
}
reads++;

for (p = buf, left=sze; left > 0; left--)
if (*p++ == ' ')
cnt++;
} while (sze != 0);

printf("%d reads, %d retries\n", reads, retries);

return cnt;
}

int main()
{
printf("%d\n", Main_cnt());
return EXIT_SUCCESS;
}

==============================
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe