class TestGetCurrentQueueInMultipleThreads(unittest.TestCase):
def test_num_current_queues_outside_with_clause(self):
self.assertEqual(dpctl.get_num_activated_queues(), 0)
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
@unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available")
def test_num_current_queues_inside_with_clause(self):
with dpctl.device_context("opencl:cpu:0"):
self.assertEqual(dpctl.get_num_activated_queues(), 1)
with dpctl.device_context("opencl:gpu:0"):
self.assertEqual(dpctl.get_num_activated_queues(), 2)
self.assertEqual(dpctl.get_num_activated_queues(), 0)
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
@unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available")
def test_num_current_queues_inside_threads(self):
from threading import Thread
def SessionThread(self):
self.assertEqual(dpctl.get_num_activated_queues(), 0)
with dpctl.device_context("opencl:gpu:0"):
self.assertEqual(dpctl.get_num_activated_queues(), 1)
Session1 = Thread(target=SessionThread(self))
Session2 = Thread(target=SessionThread(self))
with dpctl.device_context("opencl:cpu:0"):
self.assertEqual(dpctl.get_num_activated_queues(), 1)
Session1.start()
Session2.start()
class TestSyclQueue(unittest.TestCase):
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
@unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available")
def test_queue_not_equals(self):
with dpctl.device_context("opencl:gpu") as gpuQ0:
with dpctl.device_context("opencl:cpu") as cpuQ:
self.assertFalse(cpuQ.equals(gpuQ0))
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
def test_queue_equals(self):
with dpctl.device_context("opencl:gpu") as gpuQ0:
with dpctl.device_context("opencl:gpu") as gpuQ1:
self.assertTrue(gpuQ0.equals(gpuQ1))
def main():
parser = argparse.ArgumentParser(description="Black-Scholes")
parser.add_argument("--options",
dest="options",
type=int,
default=10000000)
args = parser.parse_args()
options = args.options
if dpctl.has_gpu_queues():
print("\nScheduling on OpenCL GPU\n")
with dpctl.device_context("opencl:gpu") as gpu_queue:
run(10)
else:
print("\nSkip scheduling on OpenCL GPU\n")
# if dpctl.has_gpu_queues(dpctl.backend_type.level_zero):
# print("\nScheduling on Level Zero GPU\n")
# with dpctl.device_context("level0:gpu") as gpu_queue:
# run(10)
# else:
# print("\nSkip scheduling on Level Zero GPU\n")
if dpctl.has_cpu_queues():
print("\nScheduling on OpenCL CPU\n")
with dpctl.device_context("opencl:cpu") as cpu_queue:
run(10)
else:
print("\nSkip scheduling on OpenCL CPU\n")
class TestIsInDeviceContext(unittest.TestCase):
def test_is_in_device_context_outside_device_ctxt(self):
self.assertFalse(dpctl.is_in_device_context())
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
def test_is_in_device_context_inside_device_ctxt(self):
with dpctl.device_context("opencl:gpu:0"):
self.assertTrue(dpctl.is_in_device_context())
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
@unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL CPU queues available")
def test_is_in_device_context_inside_nested_device_ctxt(self):
with dpctl.device_context("opencl:cpu:0"):
with dpctl.device_context("opencl:gpu:0"):
self.assertTrue(dpctl.is_in_device_context())
self.assertTrue(dpctl.is_in_device_context())
self.assertFalse(dpctl.is_in_device_context())
def test_dppy_array_pass():
"""Tests if dppy supports passing an array-like object DuckArray that defines `__sycl_usm_array_interface__`
to a dppy.kernel
"""
@dppy.kernel
def dppy_f(array_like_obj):
i = dppy.get_global_id(0)
array_like_obj[i] = 10
global_size = 100
hb = np.arange(0, global_size, dtype="i4")
da = DuckUSMArray(hb.shape, dtype=hb.dtype, host_buffer=hb)
if dpctl.has_gpu_queues(dpctl.backend_type.level_zero):
print("\nScheduling on OpenCL GPU\n")
with dpctl.device_context("opencl:gpu") as gpu_queue:
dppy_f[global_size, dppy.DEFAULT_LOCAL_SIZE](da)
else:
print("\nSkip scheduling on OpenCL GPU\n")
assert da[0] == 10
# limitations under the License.
#
# ===-----------------------------------------------------------------------===#
#
# \file
# Defines unit test cases for kernel submission to a sycl::queue.
# ===-----------------------------------------------------------------------===#
import ctypes
import dpctl
import unittest
import dpctl.memory as dpctl_mem
import dpctl.program as dpctl_prog
import numpy as np
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
class Test1DKernelSubmit(unittest.TestCase):
def test_create_program_from_source(self):
oclSrc = " \
kernel void axpy(global int* a, global int* b, global int* c, int d) { \
size_t index = get_global_id(0); \
c[index] = d*a[index] + b[index]; \
}"
with dpctl.device_context("opencl:gpu:0"):
q = dpctl.get_current_queue()
prog = dpctl_prog.create_program_from_source(q, oclSrc)
axpyKernel = prog.get_sycl_kernel("axpy")
abuf = dpctl_mem.MemoryUSMShared(1024 * np.dtype("i").itemsize)
bbuf = dpctl_mem.MemoryUSMShared(1024 * np.dtype("i").itemsize)
class TestMemory(unittest.TestCase):
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_memory_create(self):
nbytes = 1024
queue = dpctl.get_current_queue()
mobj = MemoryUSMShared(nbytes, queue)
self.assertEqual(mobj.nbytes, nbytes)
def _create_memory(self):
nbytes = 1024
queue = dpctl.get_current_queue()
mobj = MemoryUSMShared(nbytes, queue)
return mobj
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_memory_without_context(self):
mobj = self._create_memory()
# Without context
self.assertEqual(mobj._usm_type(), "shared")
@unittest.skipUnless(dpctl.has_cpu_queues(),
"No OpenCL CPU queues available")
def test_memory_cpu_context(self):
mobj = self._create_memory()
# CPU context
with dpctl.device_context("opencl:cpu:0"):
# type respective to the context in which
# memory was created
usm_type = mobj._usm_type()
self.assertEqual(usm_type, "shared")
current_queue = dpctl.get_current_queue()
# type as view from current queue
usm_type = mobj._usm_type(current_queue)
# type can be unknown if current queue is
# not in the same SYCL context
self.assertTrue(usm_type in ["unknown", "shared"])
@unittest.skipUnless(dpctl.has_gpu_queues(),
"No OpenCL GPU queues available")
def test_memory_gpu_context(self):
mobj = self._create_memory()
# GPU context
with dpctl.device_context("opencl:gpu:0"):
usm_type = mobj._usm_type()
self.assertEqual(usm_type, "shared")
current_queue = dpctl.get_current_queue()
usm_type = mobj._usm_type(current_queue)
self.assertTrue(usm_type in ["unknown", "shared"])
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_buffer_protocol(self):
mobj = self._create_memory()
mv1 = memoryview(mobj)
mv2 = memoryview(mobj)
self.assertEqual(mv1, mv2)
class TestMemory(unittest.TestCase):
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_memory_create(self):
nbytes = 1024
queue = dpctl.get_current_queue()
mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue)
self.assertEqual(mobj.nbytes, nbytes)
self.assertTrue(hasattr(mobj, "__sycl_usm_array_interface__"))
@unittest.expectedFailure
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_memory_create_with_np(self):
mobj = dpctl.memory.MemoryUSMShared(np.int64(16384))
self.assertTrue(hasattr(mobj, "__sycl_usm_array_interface__"))
def _create_memory(self):
nbytes = 1024
queue = dpctl.get_current_queue()
mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue)
return mobj
def _create_host_buf(self, nbytes):
ba = bytearray(nbytes)
for i in range(nbytes):
ba[i] = (i % 32) + ord("a")
return ba
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_memory_without_context(self):
mobj = self._create_memory()
# Without context
self.assertEqual(mobj.get_usm_type(), "shared")
@unittest.skipUnless(dpctl.has_cpu_queues(),
"No OpenCL CPU queues available")
def test_memory_cpu_context(self):
mobj = self._create_memory()
# CPU context
with dpctl.device_context("opencl:cpu:0"):
# type respective to the context in which
# memory was created
usm_type = mobj.get_usm_type()
self.assertEqual(usm_type, "shared")
current_queue = dpctl.get_current_queue()
# type as view from current queue
usm_type = mobj.get_usm_type(current_queue)
# type can be unknown if current queue is
# not in the same SYCL context
self.assertTrue(usm_type in ["unknown", "shared"])
@unittest.skipUnless(dpctl.has_gpu_queues(),
"No OpenCL GPU queues available")
def test_memory_gpu_context(self):
mobj = self._create_memory()
# GPU context
with dpctl.device_context("opencl:gpu:0"):
usm_type = mobj.get_usm_type()
self.assertEqual(usm_type, "shared")
current_queue = dpctl.get_current_queue()
usm_type = mobj.get_usm_type(current_queue)
self.assertTrue(usm_type in ["unknown", "shared"])
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_buffer_protocol(self):
mobj = self._create_memory()
mv1 = memoryview(mobj)
mv2 = memoryview(mobj)
self.assertEqual(mv1, mv2)
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_copy_host_roundtrip(self):
mobj = self._create_memory()
host_src_obj = self._create_host_buf(mobj.nbytes)
mobj.copy_from_host(host_src_obj)
host_dest_obj = mobj.copy_to_host()
del mobj
self.assertEqual(host_src_obj, host_dest_obj)
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_zero_copy(self):
mobj = self._create_memory()
mobj2 = type(mobj)(mobj)
self.assertTrue(mobj2.reference_obj is mobj)
mobj_data = mobj.__sycl_usm_array_interface__["data"]
mobj2_data = mobj2.__sycl_usm_array_interface__["data"]
self.assertEqual(mobj_data, mobj2_data)
@unittest.skipUnless(dpctl.has_sycl_platforms(),
"No SYCL devices except the default host device.")
def test_pickling(self):
import pickle
mobj = self._create_memory()
host_src_obj = self._create_host_buf(mobj.nbytes)
mobj.copy_from_host(host_src_obj)
mobj_reconstructed = pickle.loads(pickle.dumps(mobj))
self.assertEqual(type(mobj), type(mobj_reconstructed),
"Pickling should preserve type")
self.assertEqual(
mobj.tobytes(),
mobj_reconstructed.tobytes(),
"Pickling should preserve buffer content",
)
self.assertNotEqual(
mobj._pointer,
mobj_reconstructed._pointer,
"Pickling/unpickling changes pointer",
)
# limitations under the License.
#
# ===-----------------------------------------------------------------------===#
#
# \file
# Defines unit test cases for the SyclProgram and SyclKernel classes defined
# in sycl_core.pyx.
# ===-----------------------------------------------------------------------===#
import dpctl
import dpctl.program as dpctl_prog
import unittest
import os
@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
class TestProgramFromOCLSource(unittest.TestCase):
def test_create_program_from_source(self):
oclSrc = " \
kernel void add(global int* a, global int* b, global int* c) { \
size_t index = get_global_id(0); \
c[index] = a[index] + b[index]; \
} \
kernel void axpy(global int* a, global int* b, global int* c, int d) { \
size_t index = get_global_id(0); \
c[index] = a[index] + d*b[index]; \
}"
with dpctl.device_context("opencl:gpu:0"):
q = dpctl.get_current_queue()
prog = dpctl_prog.create_program_from_source(q, oclSrc)
self.assertIsNotNone(prog)
