added benchmark examples

Author: Chaluvadi

examples/benchmarks/bench_blas.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python
+
+#######################################################
+# Copyright (c) 2015, ArrayFire
+# All rights reserved.
+#
+# This file is distributed under 3-clause BSD license.
+# The complete license agreement can be obtained at:
+# http://arrayfire.com/licenses/BSD-3-Clause
+########################################################
+
+
+import sys
+from time import time
+
+import arrayfire as af
+
+# TODO: Remove -1 from sync() after default value has been put in
+try:
+    import numpy as np
+except ImportError:
+    np = None  # type: ignore[assignment]
+
+
+def calc_arrayfire(n):
+    A = af.randu((n, n))
+    af.sync(-1)
+
+    def run(iters):
+        for t in range(iters):
+            B = af.matmul(A, A)  # noqa: F841
+        af.sync(-1)
+
+    return run
+
+
+def calc_numpy(n):
+    np.random.seed(1)
+    A = np.random.rand(n, n).astype(np.float32)
+
+    def run(iters):
+        for t in range(iters):
+            B = np.dot(A, A)  # noqa: F841
+
+    return run
+
+
+def bench(calc, iters=100, upto=2048):
+    _, name = calc.__name__.split("_")
+    print("Benchmark N x N matrix multiply on %s" % name)
+
+    for n in range(128, upto + 128, 128):
+        run = calc(n)
+        start = time()
+        run(iters)
+        t = (time() - start) / iters
+        gflops = 2.0 * (n**3) / (t * 1e9)
+        print("Time taken for %4d x %4d: %0.4f Gflops" % (n, n, gflops))
+
+
+if __name__ == "__main__":
+
+    if len(sys.argv) > 1:
+        af.set_device(int(sys.argv[1]))
+
+    af.info()
+
+    bench(calc_arrayfire)
+    if np:
+        bench(calc_numpy, upto=512)

examples/benchmarks/bench_fft.py

@@ -0,0 +1,63 @@
+# http://arrayfire.com/licenses/BSD-3-Clause
+########################################################
+
+
+import sys
+from time import time
+
+import arrayfire as af
+
+try:
+    import numpy as np
+except ImportError:
+    np = None  # type: ignore[assignment]
+
+
+def calc_arrayfire(n):
+    A = af.randu((n, n))
+    af.sync(-1)
+
+    def run(iters):
+        for t in range(iters):
+            B = af.fft2(A)  # noqa: F841
+
+        af.sync(-1)
+
+    return run
+
+
+def calc_numpy(n):
+    np.random.seed(1)
+    A = np.random.rand(n, n).astype(np.float32)
+
+    def run(iters):
+        for t in range(iters):
+            B = np.fft.fft2(A)  # noqa: F841
+
+    return run
+
+
+def bench(calc, iters=100, upto=13):
+    _, name = calc.__name__.split("_")
+    print("Benchmark N x N 2D fft on %s" % name)
+
+    for M in range(7, upto):
+        N = 1 << M
+        run = calc(N)
+        start = time()
+        run(iters)
+        t = (time() - start) / iters
+        gflops = (10.0 * N * N * M) / (t * 1e9)
+        print("Time taken for %4d x %4d: %0.4f Gflops" % (N, N, gflops))
+
+
+if __name__ == "__main__":
+
+    if len(sys.argv) > 1:
+        af.set_device(int(sys.argv[1]))
+
+    af.info()
+
+    bench(calc_arrayfire)
+    if np:
+        bench(calc_numpy, upto=10)

examples/benchmarks/monte_carlo_pi.py

@@ -9,45 +9,53 @@
 # http://arrayfire.com/licenses/BSD-3-Clause
 ########################################################
 
+import sys
 from random import random
 from time import time
+
 import arrayfire as af
-import sys
 
 try:
     import numpy as np
 except ImportError:
-    np = None
+    np = None  # type: ignore[assignment]
 
-#alias range / xrange because xrange is faster than range in python2
+#TODO: Remove Python2 support?
+# alias range / xrange because xrange is faster than range in python2
 try:
-    frange = xrange  #Python2
+    frange = xrange  # type: ignore[name-defined]
 except NameError:
-    frange = range   #Python3
+    frange = range  # Python3
+
 
 # Having the function outside is faster than the lambda inside
 def in_circle(x, y):
-    return (x*x + y*y) < 1
+    return (x * x + y * y) < 1
+
 
 def calc_pi_device(samples):
     x = af.randu((samples,))
     y = af.randu((samples,))
     return 4 * af.sum(in_circle(x, y)) / samples
 
+
 def calc_pi_numpy(samples):
     np.random.seed(1)
     x = np.random.rand(samples).astype(np.float32)
     y = np.random.rand(samples).astype(np.float32)
-    return 4. * np.sum(in_circle(x, y)) / samples
+    return 4.0 * np.sum(in_circle(x, y)) / samples
+
 
 def calc_pi_host(samples):
     count = sum(1 for k in frange(samples) if in_circle(random(), random()))
     return 4 * float(count) / samples
 
+
 def bench(calc_pi, samples=1000000, iters=25):
     func_name = calc_pi.__name__[8:]
-    print("Monte carlo estimate of pi on %s with %d million samples: %f" % \
-          (func_name, samples/1e6, calc_pi(samples)))
+    print(
+        "Monte carlo estimate of pi on %s with %d million samples: %f" % (func_name, samples / 1e6, calc_pi(samples))
+    )
 
     start = time()
     for k in frange(iters):
@@ -56,12 +64,13 @@ def bench(calc_pi, samples=1000000, iters=25):
 
     print("Average time taken: %f ms" % (1000 * (end - start) / iters))
 
+
 if __name__ == "__main__":
-    if (len(sys.argv) > 1):
+    if len(sys.argv) > 1:
         af.set_device(int(sys.argv[1]))
     af.info()
 
     bench(calc_pi_device)
     if np:
         bench(calc_pi_numpy)
-    bench(calc_pi_host)
+    bench(calc_pi_host)