* add GC benchmark suite

replace runbench.d with a version derived from d_do_test.d

Author: rainers

benchmark/aabench/bulk.d

@@ -6,15 +6,17 @@
  * Authors:    Martin Nowak
  */
 
-import std.random, std.typetuple;
+// EXECUTE_ARGS: 20
+
+import std.random, std.typetuple, std.conv;
 
 version (VERBOSE) import std.datetime, std.stdio;
 
 alias TypeTuple!(ubyte, short, uint, long, void*, Object, ubyte[16], ubyte[64],
                  ubyte[256], ubyte[1024], ubyte[4096], ubyte[16384]
 ) ValueTuple;
 
-enum Size = 2 ^^ 24;
+size_t Size = 2 ^^ 24;
 size_t trot;
 
 void runTest(V)(ref V v)
@@ -81,8 +83,11 @@ void runTest(V)(ref V v)
     version (VERBOSE) writeln();
 }
 
-void main()
+void main(string[] args)
 {
+    if (args.length > 1)
+        Size = 1 << to!int(args[1]);
+
     version (RANDOMIZE)
         trot = uniform(1, 200);
     else

benchmark/aabench/string.d

@@ -6,6 +6,8 @@
  * Authors:    Martin Nowak
  */
 
+// EXECUTE_ARGS: extra-files/dante.txt
+
 import std.array, std.file, std.path;
 
 void runTest(string[] words)
@@ -20,9 +22,15 @@ void runTest(string[] words)
 
 void main(string[] args)
 {
-    // test/bin/aabench/string => test/extra-files/dante.txt
-    auto path = dirName(dirName(dirName(absolutePath(args[0]))));
-    path = buildPath(path, "extra-files", "dante.txt");
+    string path;
+    if (args.length > 1)
+        path = args[1];
+    else
+    {
+        // test/bin/aabench/string => test/extra-files/dante.txt
+        path = dirName(dirName(dirName(absolutePath(args[0]))));
+        path = buildPath(path, "extra-files", "dante.txt");
+    }
     auto words = split(std.file.readText(path));
     runTest(words);
 }

benchmark/gcbench/conalloc.d

@@ -0,0 +1,60 @@
+/**
+ * The goal of this program is to do very CPU intensive work with allocations in threads
+ *
+ * Copyright: Copyright Leandro Lucarella 2014.
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Authors:   Leandro Lucarella
+ */
+// EXECUTE_ARGS: 50 4 extra-files/dante.txt
+
+import core.thread;
+import core.atomic;
+import std.conv;
+import std.file;
+import std.digest.sha;
+
+auto N = 100;
+auto NT = 2;
+
+__gshared ubyte[] BYTES;
+shared(int) running; // Atomic
+
+void main(char[][] args)
+{
+    auto fname = args[0];
+    if (args.length > 3)
+        fname = args[3];
+    if (args.length > 2)
+        NT = to!(int)(args[2]);
+    if (args.length > 1)
+        N = to!(int)(args[1]);
+    N /= NT;
+
+    atomicStore(running, NT);
+    BYTES = cast(ubyte[]) std.file.read(fname);
+    auto threads = new Thread[NT];
+    foreach(ref thread; threads)
+    {
+        thread = new Thread(&doSha);
+        thread.start();
+    }
+    while (atomicLoad(running))
+    {
+        auto a = new ubyte[](BYTES.length);
+        a[] = cast(ubyte[]) BYTES[];
+        Thread.yield();
+    }
+    foreach(thread; threads)
+        thread.join();
+}
+
+void doSha()
+{
+    for (size_t i = 0; i < N; i++)
+    {
+        auto sha = new SHA1; // undefined identifier SHA512?
+        sha.put(BYTES);
+    }
+    running += -1;
+}
+

benchmark/gcbench/conappend.d

@@ -0,0 +1,66 @@
+/**
+ * The goal of this program is to do concurrent allocations in threads
+ *
+ * Copyright: Copyright Leandro Lucarella 2014.
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Authors:   Leandro Lucarella
+ */
+// EXECUTE_ARGS: 50 4 extra-files/dante.txt
+
+import core.thread;
+import core.atomic;
+import std.conv;
+import std.file;
+import std.exception;
+
+auto N = 100;
+auto NT = 2;
+
+__gshared ubyte[] BYTES;
+shared(int) running; // Atomic
+
+void main(char[][] args)
+{
+    auto fname = args[0];
+    if (args.length > 3)
+        fname = args[3];
+    if (args.length > 2)
+        NT = to!(int)(args[2]);
+    if (args.length > 1)
+        N = to!(int)(args[1]);
+    N /= NT;
+
+    atomicStore(running, NT);
+    BYTES = cast(ubyte[]) std.file.read(fname);
+    auto threads = new Thread[NT];
+    foreach(ref thread; threads)
+    {
+        thread = new Thread(&doAppend);
+        thread.start();
+    }
+    while (atomicLoad(running))
+    {
+        auto a = new ubyte[](BYTES.length);
+        a[] = cast(ubyte[]) BYTES[];
+        Thread.yield();
+    }
+    foreach(thread; threads)
+        thread.join();
+}
+
+void doAppend()
+{
+    for (size_t i = 0; i < N; i++)
+    {
+        int[] arr;
+        for (int j = 0; j < 1000; j++)
+            arr ~= j;
+
+        int sum = 0;
+        foreach (a; arr)
+            sum += a;
+        enforce(sum == 1000 * 999 / 2, "bad sum");
+    }
+    running += -1;
+}
+

benchmark/gcbench/concpu.d

@@ -0,0 +1,60 @@
+/**
+ * The goal of this program is to do very CPU intensive work in threads
+ *
+ * Copyright: Copyright Leandro Lucarella 2014.
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Authors:   Leandro Lucarella
+ */
+// EXECUTE_ARGS: 50 4 extra-files/dante.txt
+
+import core.thread;
+import core.atomic;
+import std.conv;
+import std.file;
+import std.digest.sha;
+
+auto N = 100;
+auto NT = 2;
+
+__gshared ubyte[] BYTES;
+shared(int) running; // Atomic
+
+void main(char[][] args)
+{
+    auto fname = args[0];
+    if (args.length > 3)
+        fname = args[3];
+    if (args.length > 2)
+        NT = to!(int)(args[2]);
+    if (args.length > 1)
+        N = to!(int)(args[1]);
+    N /= NT;
+
+    atomicStore(running, NT);
+    BYTES = cast(ubyte[]) std.file.read(fname);
+    auto threads = new Thread[NT];
+    foreach(ref thread; threads)
+    {
+        thread = new Thread(&doSha);
+        thread.start();
+    }
+    while (atomicLoad(running))
+    {
+        auto a = new void[](BYTES.length);
+        a[] = cast(void[]) BYTES[];
+        Thread.yield();
+    }
+    foreach(thread; threads)
+        thread.join();
+}
+
+void doSha()
+{
+    auto sha = new SHA1; // undefined identifier SHA512?
+    for (size_t i = 0; i < N; i++)
+    {
+        sha.put(BYTES);
+    }
+    running += -1;
+}
+

benchmark/gcbench/dlist.d

@@ -0,0 +1,57 @@
+/**
+ * Copyright: Copyright Rainer Schuetze 2014.
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Authors:   Rainer Schuetze
+ *
+ * This test reads a text file, then splits the result into white space delimited words.
+ * The result is a double linked list of strings referencing the full text.
+ * Regarding GC activity, this test probes collection of linked lists.
+ */
+// EXECUTE_ARGS: extra-files/dante.txt 100 9767600
+
+import std.stdio;
+import std.conv;
+import std.file;
+import std.string;
+import std.exception;
+
+// double-linked list with circular next/prev pointers
+struct Node
+{
+    string token;
+    Node* next; // first in root
+    Node* prev; // last in root
+}
+
+void main(string[] args)
+{
+    enforce(args.length > 2, "usage: dlist <file-name> <iterations> [expected-result]");
+    string txt = cast(string) std.file.read(args[1]);
+    uint cnt = to!uint(args[2]);
+    uint allwords = 0;
+    for(uint i = 0; i < cnt; i++)
+    {
+        Node* rootNode = new Node;
+        rootNode.next = rootNode;
+        rootNode.prev = rootNode;
+
+        auto words = txt.split();
+        foreach(w; words)
+        {
+            Node* n = new Node;
+            n.token = w;
+            // insert at end of list
+            n.next = rootNode;
+            n.prev = rootNode.prev;
+            rootNode.prev.next = n;
+            rootNode.prev = n;
+        }
+
+        for(Node* p = rootNode.next; p != rootNode; p = p.next)
+            allwords++;
+    }
+    writeln("words: ", allwords);
+
+    if(args.length > 3)
+        enforce(allwords == to!size_t(args[3]));
+}

benchmark/gcbench/rand_small.d

@@ -11,14 +11,17 @@
  *    (See accompanying file LICENSE or copy at
  *          http://www.boost.org/LICENSE_1_0.txt)
  */
-import std.random, core.memory, std.stdio;
+import std.random, core.memory, std.stdio, std.conv;
 
-enum nIter = 1000;
+void main(string[] args)
+{
+    size_t nIter = 1000;
+    if(args.length > 1)
+        nIter = to!size_t(args[1]);
 
-void main() {
     auto ptrs = new void*[4096];
 
-    // Allocate 1024 large blocks with size uniformly distributed between 8
+    // Allocate large blocks with size uniformly distributed between 8
     // and 2048 bytes.
     foreach(i; 0..nIter) {
         foreach(ref ptr; ptrs) {

benchmark/gcbench/slist.d

@@ -0,0 +1,49 @@
+/**
+ * Copyright: Copyright Rainer Schuetze 2014.
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Authors:   Rainer Schuetze
+ *
+ * This test reads a text file, then splits the result into white space delimited words.
+ * The result is a single linked list of strings referencing the full text.
+ * Regarding GC activity, this test probes collection of linked lists.
+ */
+// EXECUTE_ARGS: extra-files/dante.txt 100 9767600
+
+import std.stdio;
+import std.conv;
+import std.file;
+import std.string;
+import std.exception;
+
+struct Node
+{
+    string token;
+    Node* next;
+}
+
+void main(string[] args)
+{
+    enforce(args.length > 2, "usage: slist <file-name> <iterations> [expected-result]");
+    string txt = cast(string) std.file.read(args[1]);
+    uint cnt = to!uint(args[2]);
+    uint allwords = 0;
+    for(uint i = 0; i < cnt; i++)
+    {
+        Node* firstNode;
+        auto words = txt.split();
+        foreach(w; words)
+        {
+            Node* n = new Node;
+            n.token = w;
+            n.next = firstNode;
+            firstNode = n;
+        }
+
+        for(Node* p = firstNode; p; p = p.next)
+            allwords++;
+    }
+    writeln("words: ", allwords);
+
+    if(args.length > 3)
+        enforce(allwords == to!size_t(args[3]));
+}