Display more info in bench, specially speedup wrt NumPy

Author: FrancescAlted

bench/ndarray/compute_where.py

@@ -13,7 +13,7 @@
 
 import blosc2
 
-shape = (4_000, 5_000)
+shape = (40_000, 5_000)
 chunks = (10, 5_000)
 blocks = (1, 1000)
 # Comment out the next line to force chunks and blocks above
@@ -33,13 +33,13 @@
 t0 = time()
 npc = npa**2 + npb**2 > 2 * npa * npb + 1
 npd = np.where(npc, 0, 1)
-t = time() - t0
+tref = t = time() - t0
 print(f"Time to compute where expression (NumPy): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
 
 t0 = time()
 npc = ne.evaluate('where(a**2 + b**2 > 2 * a * b + 1, 0, 1)', local_dict={'a': npa, 'b': npb})
 t = time() - t0
-print(f"Time to compute where expression (NumExpr): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to compute where expression (NumExpr): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 s = blosc2.asarray(nps, chunks=chunks, blocks=blocks, cparams=cparams)
 print(f"*** Working with NDArray with shape: {s.shape}, chunks: {s.chunks}, blocks: {s.blocks},"
@@ -53,43 +53,43 @@
 c = a**2 + b**2 > 2 * a * b + 1
 d = c.where(0, 1).compute(cparams=cparams)
 t = time() - t0
-print(f"Time to compute where expression (compute): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to compute where expression (compute): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 # Compute the whole slice: output is a NumPy array
 t0 = time()
 c = a**2 + b**2 > 2 * a * b + 1
 npd = c.where(0, 1)[:]
 t = time() - t0
-print(f"Time to compute where expression (getitem): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to compute where expression (getitem): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 print("*** Extracting rows")
 # Compute and get row values: NumPy
 t0 = time()
 npc = npa**2 + npb**2 > 2 * npa * npb + 1
 npd = nps[npc]
-t = time() - t0
+tref = t = time() - t0
 print(f"Time to get row values (NumPy): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
 
 # Compute and get row values: output is a NDArray
 t0 = time()
 npd = s[a**2 + b**2 > 2 * a * b + 1].compute(cparams=cparams)
 t = time() - t0
-print(f"Time to get row values (compute): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to get row values (compute): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 # Compute and get row values: output is a NDArray
 t0 = time()
 npd = s['a**2 + b**2 > 2 * a * b + 1'].compute(cparams=cparams)
 t = time() - t0
-print(f"Time to get row values (compute, string): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to get row values (compute, string): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 # Compute and get row values: output is a NumPy array
 t0 = time()
 npd = s[a**2 + b**2 > 2 * a * b + 1][:]
 t = time() - t0
-print(f"Time to get row values (getitem): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to get row values (getitem): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")
 
 # Compute and get row values: output is a NumPy array
 t0 = time()
 npd = s['a**2 + b**2 > 2 * a * b + 1'][:]
 t = time() - t0
-print(f"Time to get row values (getitem, string): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s")
+print(f"Time to get row values (getitem, string): {t:.3f} s; {nps.nbytes/2**30/t:.3f} GB/s; {tref / t:.1f}x wrt NumPy")

bench/ndarray/reduce_expr.py

@@ -17,8 +17,8 @@
 
 import blosc2
 
-shape = (50, 100, 10_000)
-chunks = [5, 100, 10_000]
+shape = (100, 100, 10_000)
+chunks = [10, 100, 10_000]
 blocks = [4, 10, 1_000]
 # Comment out the next line to force chunks and blocks above
 chunks, blocks = None, None
@@ -41,6 +41,7 @@
 x = blosc2.asarray(npx, chunks=chunks, blocks=blocks)
 y = blosc2.asarray(npy, chunks=chunks, blocks=blocks)
 z = blosc2.asarray(npz, chunks=chunks, blocks=blocks)
+print(f"*** cratios: x={x.schunk.cratio:.2f}x, y={y.schunk.cratio:.2f}x, z={z.schunk.cratio:.2f}x")
 
 expr = "(x**2 + y**2 * z** 2) < 1"
 
@@ -52,24 +53,28 @@
     npexpr = expr.replace("sin", "np.sin").replace("cos", "np.cos")
     t0 = time()
     npres = eval(npexpr, vardict).sum(axis=axis)
-    print("NumPy took %.3f s" % (time() - t0))
+    tref = time() - t0
+    print("NumPy took %.3f s" % tref)
     # ne.set_num_threads(1)
     # nb.set_num_threads(1)  # this does not work that well; better use the NUMBA_NUM_THREADS env var
     t0 = time()
     out = ne.evaluate(expr, vardict).sum(axis=axis)
-    print("NumExpr took %.3f s" % (time() - t0))
+    t1 = time() - t0
+    print(f"NumExpr took {t1:.3f} s; {tref / t1:.1f}x wrt NumPy")
 
     # Reduce with Blosc2
     c = eval(expr)
     t0 = time()
     d = c.compute()
     d = d.sum(axis=axis)
-    print("LazyExpr+compute took %.3f s" % (time() - t0))
+    t1 = time() - t0
+    print(f"LazyExpr+compute took {t1:.3f} s; {tref / t1:.1f}x wrt NumPy")
     # Check
     np.testing.assert_allclose(d[()], npres, rtol=rtol, atol=atol)
     t0 = time()
     d = c[:]
     d = d.sum(axis=axis)
-    print("LazyExpr+getitem took %.3f s" % (time() - t0))
+    t1 = time() - t0
+    print(f"LazyExpr+getitem took {t1:.3f} s; {tref / t1:.1f}x wrt NumPy")
     # Check
     np.testing.assert_allclose(d[()], npres, rtol=rtol, atol=atol)