Improve dpctl.memory._memory coverage

Author: oleksandr-pavlyk

dpctl/tests/test_sycl_usm.py

@@ -48,12 +48,20 @@ def __sycl_usm_array_interface(self):
     not has_sycl_platforms(),
     reason="No SYCL devices except the default host device.",
 )
-def test_memory_create():
+def test_memory_create(memory_ctor):
+    import sys
+
     nbytes = 1024
-    queue = dpctl.get_current_queue()
-    mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue)
+    queue = dpctl.SyclQueue()
+    mobj = memory_ctor(nbytes, alignment=64, queue=queue)
     assert mobj.nbytes == nbytes
     assert hasattr(mobj, "__sycl_usm_array_interface__")
+    assert len(mobj) == nbytes
+    assert mobj.size == nbytes
+    assert mobj._context == queue.sycl_context
+    assert type(repr(mobj)) is str
+    assert type(bytes(mobj)) is bytes
+    assert sys.getsizeof(mobj) > nbytes
 
 
 @pytest.mark.skipif(
@@ -69,7 +77,7 @@ def test_memory_create_with_np():
 
 def _create_memory():
     nbytes = 1024
-    queue = dpctl.get_current_queue()
+    queue = dpctl.SyclQueue()
     mobj = MemoryUSMShared(nbytes, alignment=64, queue=queue)
     return mobj
 
@@ -90,38 +98,36 @@ def test_memory_without_context():
 
     # Without context
     assert mobj.get_usm_type() == "shared"
+    assert mobj.get_usm_type(syclobj=dpctl.SyclContext()) == "shared"
 
 
 @pytest.mark.skipif(not has_cpu(), reason="No SYCL CPU device available.")
 def test_memory_cpu_context():
     mobj = _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()
-        assert usm_type == "shared"
+    # type respective to the context in which
+    # memory was created
+    usm_type = mobj.get_usm_type()
+    assert 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
-        assert usm_type in ["unknown", "shared"]
+    cpu_queue = dpctl.SyclQueue("cpu")
+    # type as view from CPU queue
+    usm_type = mobj.get_usm_type(cpu_queue)
+    # type can be unknown if current queue is
+    # not in the same SYCL context
+    assert usm_type in ["unknown", "shared"]
 
 
 @pytest.mark.skipif(not has_gpu(), reason="No OpenCL GPU queues available")
 def test_memory_gpu_context():
     mobj = _create_memory()
 
     # GPU context
-    with dpctl.device_context("opencl:gpu:0"):
-        usm_type = mobj.get_usm_type()
-        assert usm_type == "shared"
-        current_queue = dpctl.get_current_queue()
-        usm_type = mobj.get_usm_type(current_queue)
-        assert usm_type in ["unknown", "shared"]
+    usm_type = mobj.get_usm_type()
+    assert usm_type == "shared"
+    gpu_queue = dpctl.SyclQueue("opencl:gpu")
+    usm_type = mobj.get_usm_type(gpu_queue)
+    assert usm_type in ["unknown", "shared"]
 
 
 @pytest.mark.skipif(
@@ -166,10 +172,10 @@ def test_zero_copy():
     not has_sycl_platforms(),
     reason="No SYCL devices except the default host device.",
 )
-def test_pickling():
+def test_pickling(memory_ctor):
     import pickle
 
-    mobj = _create_memory()
+    mobj = memory_ctor(1024, alignment=64)
     host_src_obj = _create_host_buf(mobj.nbytes)
     mobj.copy_from_host(host_src_obj)
 
@@ -185,6 +191,27 @@ def test_pickling():
     ), "Pickling/unpickling should be changing pointer"
 
 
+@pytest.mark.skipif(
+    not has_sycl_platforms(),
+    reason="No SYCL devices except the default host device.",
+)
+def test_pickling_reconstructor_invalid_type(memory_ctor):
+    import pickle
+
+    mobj = memory_ctor(1024, alignment=64)
+    good_pickle_bytes = pickle.dumps(mobj)
+    usm_types = expected_usm_type(memory_ctor).encode("utf-8")
+    i = good_pickle_bytes.index(usm_types)
+    assert i > 4
+    bad_pickle_bytes = (
+        good_pickle_bytes[: i - 4]
+        + b"\x07\x00\x00\x00unknown"
+        + good_pickle_bytes[i + len(usm_types) :]
+    )
+    with pytest.raises(ValueError):
+        pickle.loads(bad_pickle_bytes)
+
+
 @pytest.fixture(params=[MemoryUSMShared, MemoryUSMDevice, MemoryUSMHost])
 def memory_ctor(request):
     return request.param
@@ -389,3 +416,46 @@ def test_with_constructor(memory_ctor):
         syclobj=buf.sycl_device.filter_string,
     )
     check_view(v)
+
+
+@pytest.mark.skipif(
+    not has_sycl_platforms(),
+    reason="No SYCL devices except the default host device.",
+)
+def test_cpython_api(memory_ctor):
+    import ctypes
+    import sys
+
+    mobj = memory_ctor(1024)
+    mod = sys.modules[mobj.__class__.__module__]
+    # get capsules storing function pointers
+    mem_ptr_fn_cap = mod.__pyx_capi__["get_usm_pointer"]
+    mem_ctx_fn_cap = mod.__pyx_capi__["get_context"]
+    mem_nby_fn_cap = mod.__pyx_capi__["get_nbytes"]
+    # construct Python callable to invoke "get_usm_pointer"
+    cap_ptr_fn = ctypes.pythonapi.PyCapsule_GetPointer
+    cap_ptr_fn.restype = ctypes.c_void_p
+    cap_ptr_fn.argtypes = [ctypes.py_object, ctypes.c_char_p]
+    mem_ptr_fn_ptr = cap_ptr_fn(
+        mem_ptr_fn_cap, b"DPCTLSyclUSMRef (struct Py_MemoryObject *)"
+    )
+    mem_ctx_fn_ptr = cap_ptr_fn(
+        mem_ctx_fn_cap, b"DPCTLSyclContextRef (struct Py_MemoryObject *)"
+    )
+    mem_nby_fn_ptr = cap_ptr_fn(
+        mem_nby_fn_cap, b"size_t (struct Py_MemoryObject *)"
+    )
+    callable_maker = ctypes.PYFUNCTYPE(ctypes.c_void_p, ctypes.py_object)
+    get_ptr_fn = callable_maker(mem_ptr_fn_ptr)
+    get_ctx_fn = callable_maker(mem_ctx_fn_ptr)
+    get_nby_fn = callable_maker(mem_nby_fn_ptr)
+
+    capi_ptr = get_ptr_fn(mobj)
+    direct_ptr = mobj._pointer
+    assert capi_ptr == direct_ptr
+    capi_ctx_ref = get_ctx_fn(mobj)
+    direct_ctx_ref = mobj._context.addressof_ref()
+    assert capi_ctx_ref == direct_ctx_ref
+    capi_nbytes = get_nby_fn(mobj)
+    direct_nbytes = mobj.nbytes
+    assert capi_nbytes == direct_nbytes