changes blacksholes example to adapt to change in memory buffer interpretation of queue=None

Author: oleksandr-pavlyk

examples/cython/sycl_direct_linkage/README.md

@@ -26,7 +26,7 @@ To illustrate the queue creation overhead in each call, compare execution of def
 which is Intel Gen9 GPU on OpenCL backend:
 
 ```
-(idp) [11:24:38 ansatnuc04 sycl_direct_linkage]$ SYCL_BE=PI_OPENCL python bench.py
+(idp) [11:24:38 ansatnuc04 sycl_direct_linkage]$ SYCL_DEVICE_FILTER=opencl:gpu python bench.py
 ========== Executing warm-up ==========
 NumPy result:  [1. 1. 1. ... 1. 1. 1.]
 SYCL(default_device) result: [1. 1. 1. ... 1. 1. 1.]
@@ -37,7 +37,7 @@ Times for NumPy
 [3.5394036192446947, 3.498957809060812, 3.4925728561356664, 3.5036555202677846, 3.493739523924887]
 ```
 
-vs. timing when `dpctl`'s current queue is being reused:
+vs. timing when `dpctl`'s queue is being reused:
 
 ```
 (idp) [11:29:14 ansatnuc04 sycl_buffer]$ python bench.py

examples/cython/usm_memory/blackscholes.pyx

@@ -29,7 +29,18 @@ cdef extern from "sycl_blackscholes.hpp":
     cdef void cpp_blackscholes[T](c_dpctl.DPCTLSyclQueueRef, size_t n_opts, T* option_params, T* callput) except +
     cdef void cpp_populate_params[T](c_dpctl.DPCTLSyclQueueRef, size_t n_opts, T* option_params, T pl, T ph, T sl, T sh, T tl, T th, T rl, T rh, T vl, T vh, int seed) except +
 
-def black_scholes_price(floating[:, ::1] option_params):
+cdef c_dpctl.SyclQueue from_queue_keyword(queue):
+    if (queue is None):
+        return c_dpctl.SyclQueue()
+    elif isinstance(queue, dpctl.SyclQueue):
+        return <c_dpctl.SyclQueue> queue
+    else:
+        return c_dpctl.SyclQueue(queue)
+    # use default
+    return c_dpctl.SyclQueue()
+
+
+def black_scholes_price(floating[:, ::1] option_params, queue=None):
     cdef size_t n_opts = option_params.shape[0]
     cdef size_t n_params = option_params.shape[1]
     cdef size_t n_bytes = 0
@@ -49,19 +60,19 @@ def black_scholes_price(floating[:, ::1] option_params):
             "Each row must specify (current_price, strike_price, maturity, interest_rate, volatility)."
             ).format(n_params))
 
-    q = c_dpctl.get_current_queue()
+    q = from_queue_keyword(queue)
     q_ptr = q.get_queue_ref()
     if (floating is double):
         n_bytes = 2*n_opts * sizeof(double)
-        mobj = c_dpctl_mem.MemoryUSMShared(n_bytes)
+        mobj = c_dpctl_mem.MemoryUSMShared(n_bytes, queue=q)
         callput_arr = np.ndarray((n_opts, 2), buffer=mobj, dtype='d')
         call_put_prices = callput_arr
         dp1 = &option_params[0,0]
         dp2 = &call_put_prices[0,0];
         cpp_blackscholes[double](q_ptr, n_opts, dp1, dp2)
     elif (floating is float):
         n_bytes = 2*n_opts * sizeof(float)
-        mobj = c_dpctl_mem.MemoryUSMShared(n_bytes)
+        mobj = c_dpctl_mem.MemoryUSMShared(n_bytes, queue=q)
         callput_arr = np.ndarray((n_opts, 2), buffer=mobj, dtype='f')
         call_put_prices = callput_arr
         fp1 = &option_params[0,0]
@@ -70,7 +81,7 @@ def black_scholes_price(floating[:, ::1] option_params):
 
     return callput_arr
 
-def populate_params(floating[:, ::1] option_params, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, int seed):
+def populate_params(floating[:, ::1] option_params, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, int seed, queue=None):
     cdef size_t n_opts = option_params.shape[0]
     cdef size_t n_params = option_params.shape[1]
 
@@ -85,7 +96,7 @@ def populate_params(floating[:, ::1] option_params, pl, ph, sl, sh, tl, th, rl,
             "Each row must specify (current_price, strike_price, maturity, interest_rate, volatility)."
             ).format(n_params))
 
-    q = c_dpctl.get_current_queue()
+    q = from_queue_keyword(queue)
     q_ptr = q.get_queue_ref()
     if (floating is double):
         dp = &option_params[0,0]

examples/cython/usm_memory/run.py

@@ -21,12 +21,12 @@
 from reference_black_scholes import ref_python_black_scholes
 
 
-def gen_option_params(n_opts, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, dtype):
-    usm_mem = dpctl_mem.MemoryUSMShared(n_opts * 5 * np.dtype(dtype).itemsize)
-    # usm_mem2 = dpctl_mem.MemoryUSMDevice(n_opts * 5 * np.dtype(dtype).itemsize)
+def gen_option_params(n_opts, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, dtype, queue=None):
+    nbytes = n_opts * 5 * np.dtype(dtype).itemsize
+    usm_mem = dpctl_mem.MemoryUSMShared(nbytes, queue=queue)
     params = np.ndarray(shape=(n_opts, 5), buffer=usm_mem, dtype=dtype)
     seed = 1234
-    bs.populate_params(params, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, seed)
+    bs.populate_params(params, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, seed, queue=queue)
     return params
 
 
@@ -47,38 +47,42 @@ def gen_option_params(n_opts, pl, ph, sl, sh, tl, th, rl, rh, vl, vh, dtype):
 # compute prices in CPython
 X_ref = np.array([ref_python_black_scholes(*opt) for opt in opts], dtype="d")
 
-print(np.allclose(Xgpu, X_ref, atol=1e-5))
+print("Correctness check: allclose(Xgpu, Xref) == ", np.allclose(Xgpu, X_ref, atol=1e-5))
 
 n_opts = 3 * 10 ** 6
 
 # compute on CPU sycl device
 import timeit
 
-for _ in range(3):
+cpu_q = dpctl.SyclQueue("opencl:cpu:0")
+opts1 = gen_option_params(
+    n_opts, 20.0, 30.0, 22.0, 29.0, 18.0, 24.0, 0.01, 0.05, 0.01, 0.05, "d", queue=cpu_q
+)
+
+gpu_q = dpctl.SyclQueue("level_zero:gpu:0")
+opts2 = gen_option_params(
+    n_opts, 20.0, 30.0, 22.0, 29.0, 18.0, 24.0, 0.01, 0.05, 0.01, 0.05, "d", queue=gpu_q
+)
 
-    dpctl.set_global_queue("opencl:cpu:0")
-    print("Using : {}".format(dpctl.get_current_queue().sycl_device.name))
+cpu_times = []
+gpu_times = []
+for _ in range(5):
 
     t0 = timeit.default_timer()
-    opts1 = gen_option_params(
-        n_opts, 20.0, 30.0, 22.0, 29.0, 18.0, 24.0, 0.01, 0.05, 0.01, 0.05, "d"
-    )
-    X1 = bs.black_scholes_price(opts1)
+    X1 = bs.black_scholes_price(opts1, queue=cpu_q)
     t1 = timeit.default_timer()
 
-    print("Elapsed: {}".format(t1 - t0))
+    cpu_times.append(t1-t0)
 
     # compute on GPU sycl device
-    dpctl.set_global_queue("level_zero:gpu:0")
-    print("Using : {}".format(dpctl.get_current_queue().sycl_device.name))
 
     t0 = timeit.default_timer()
-    opts2 = gen_option_params(
-        n_opts, 20.0, 30.0, 22.0, 29.0, 18.0, 24.0, 0.01, 0.05, 0.01, 0.05, "d"
-    )
-    X2 = bs.black_scholes_price(opts2)
+    X2 = bs.black_scholes_price(opts2, queue=gpu_q)
     t1 = timeit.default_timer()
-    print("Elapsed: {}".format(t1 - t0))
+    gpu_times.append(t1-t0)
+
+print("Using      : {}".format(cpu_q.sycl_device.name))
+print("Wall times : {}".format(cpu_times))
 
-print(np.abs(opts1 - opts2).max())
-print(np.abs(X2 - X1).max())
+print("Using      : {}".format(gpu_q.sycl_device.name))
+print("Wall times : {}".format(gpu_times))