Cleanup redundant 'time' word

bench/bench-boost.cpp

@@ -51,7 +51,7 @@ static void prod(void *arg)
   }
 }
 
-static void test_buffer(size_t n)
+static void test_queue(size_t n)
 {
   const int cpu_count   = get_cpu_count();
   const int prod_count  = cpu_count/2;
@@ -92,7 +92,7 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+    test_function("QueueMPMC", 1000000, test_queue);
   exit(0);
 }
 

bench/bench-collectionc.c

@@ -254,16 +254,16 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
+    test_function("Rbtree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   exit(0);
 }

bench/bench-concurrentqueue.cpp

@@ -51,7 +51,7 @@ static void prod(void *arg)
   }
 }
 
-static void test_buffer(size_t n)
+static void test_queue(size_t n)
 {
   const int cpu_count   = get_cpu_count();
   const int prod_count  = cpu_count/2;
@@ -92,7 +92,7 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+    test_function("Queue MPMC", 1000000, test_queue);
   exit(0);
 }
 

bench/bench-densehashmap.cpp

@@ -135,10 +135,10 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict", 1000000, test_dict2);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+    test_function("DictStr", 1000000, test_dict_str);
   exit(0);
 }

bench/bench-flathashmap.cpp

@@ -129,12 +129,12 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict", 1000000, test_dict2);
   if (n == 46)
-    test_function("Dict(u+l)time", 1000000, test_dict2_linear);
+    test_function("DictLinear", 1000000, test_dict2_linear);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+    test_function("DictStr", 1000000, test_dict_str);
   exit(0);
 }

bench/bench-glib.c

@@ -190,16 +190,16 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
+    test_function("Rbtree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   exit(0);
 }

bench/bench-hopscotchmap.cpp

@@ -15,7 +15,7 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include "src/hopscotch_map.h"
+#include "hopscotch_map.h"
 
 using namespace tsl;
 using namespace std;
@@ -113,10 +113,10 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict", 1000000, test_dict2);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+    test_function("DictStr", 1000000, test_dict_str);
   exit(0);
 }

bench/bench-klib.c

@@ -189,17 +189,17 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]): 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-    test_function("B-tree time", 1000000, test_rbtree);
+    test_function("B-tree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("DictOA time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   exit(0);
 }
 

bench/bench-libdynamic.c

@@ -148,10 +148,10 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 41)
-    test_function("Dict B time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   exit(0);
  }

bench/bench-liblfds.c

@@ -124,7 +124,7 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 60)
-    test_function("Buffer time", 1000000, test_buffer);
+    test_function("Buffer", 1000000, test_buffer);
   exit(0);
 }
 

bench/bench-libsrt.c

@@ -64,9 +64,9 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   exit(0);
 }
 

bench/bench-nedtries.c

@@ -92,9 +92,9 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 45)
-    test_function("Dict No Alloc time", 1000000, test_dict_noalloc);
+    test_function("Dict(NoAlloc)", 1000000, test_dict_noalloc);
   
   exit(0);
 }

bench/bench-qt.cpp

@@ -166,18 +166,18 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-     test_function("Rbtree time", 1000000, test_rbtree);
+     test_function("Rbtree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("Dict(m)time", 1000000, test_dict1);
+    test_function("Dict(m)", 1000000, test_dict1);
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict(u)", 1000000, test_dict2);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   exit(0);
 }

bench/bench-sparsepp.cpp

@@ -113,10 +113,10 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict", 1000000, test_dict2);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+    test_function("DictStr", 1000000, test_dict_str);
   exit(0);
 }

bench/bench-stl.cpp

@@ -242,26 +242,26 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
+    test_function("Rbtree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("Dict(m)time", 1000000, test_dict1);
+    test_function("Dict(m)", 1000000, test_dict1);
   if (n == 42)
-    test_function("Dict(u)time", 1000000, test_dict2);
+    test_function("Dict(u)", 1000000, test_dict2);
   if (n == 46)
-    test_function("Dict(u+l)time", 1000000, test_dict2_linear);
+    test_function("DictLinear(u)", 1000000, test_dict2_linear);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   if (n == 43)
-    test_function("DictS(u)  time", 1000000, test_dict_str);
+    test_function("DictStr(u)", 1000000, test_dict_str);
   if (n == 44)
-    test_function("DictS(m)  time", 1000000, test_dict_str2);
+    test_function("DictStr(m)", 1000000, test_dict_str2);
   if (n == 50)
-    test_function("Sort   time", 10000000, test_sort);
+    test_function("Sort", 10000000, test_sort);
   if (n == 51)
-    test_function("Stable Sort time", 10000000, test_stable_sort);
+    test_function("Stable Sort", 10000000, test_stable_sort);
   exit(0);
 }

bench/bench-tommyds.c

@@ -210,14 +210,14 @@ int main(int argc, const char *argv[])
 {
   int n = (argc > 1) ? atoi(argv[1]) : 0;
   if (n == 10)
-    test_function("List   time",10000000, test_list);
+    test_function("List",10000000, test_list);
   if (n == 20)
-    test_function("Array  time", 100000000, test_array);
+    test_function("Array", 100000000, test_array);
   if (n == 30)
-    test_function("Rbtree time", 1000000, test_rbtree);
+    test_function("Rbtree", 1000000, test_rbtree);
   if (n == 40)
-    test_function("Dict   time", 1000000, test_dict);
+    test_function("Dict", 1000000, test_dict);
   if (n == 41)
-    test_function("DictB  time", 1000000, test_dict_big);
+    test_function("DictBig", 1000000, test_dict_big);
   exit(0);
 }

bench/bench-xxhash.c

@@ -38,7 +38,7 @@ int main(int argc, const char *argv[])
   if (n == 70) {
     n = (argc > 2) ? atoi(argv[2]) : 100000000;
     test_hash_prepare(n);
-    test_function("XXHASH64 time", n, test_hash);
+    test_function("XXHASH64", n, test_hash);
     test_hash_final();
   }