Equivalency checking helpers.

Diptorup Deb · Diptorup Deb · commit 99f9080274fa · 2020-10-04T00:27:10.000-05:00
-- Added a way to check if two DPPLSyclQueueRef and the SyclQueue
       wrappers point to the same sycl queue.
    -- Same thing for DPPLSyclContextRef and SyclContext.
diff --git a/backends/include/dppl_sycl_context_interface.h b/backends/include/dppl_sycl_context_interface.h
@@ -35,6 +35,18 @@
 
 DPPL_C_EXTERN_C_BEGIN
 
+/*!
+ * @brief Checks if two DPPLSyclContextRef objects point to the same
+ * sycl::context.
+ *
+ * @param    CtxRef1       First opaque pointer to the sycl context.
+ * @param    CtxRef2       Second opaque pointer to the sycl context.
+ * @return   True if the underlying sycl::context are same, false otherwise.
+ */
+DPPL_API
+bool DPPLContext_AreEq (__dppl_keep const DPPLSyclContextRef CtxRef1,
+                        __dppl_keep const DPPLSyclContextRef CtxRef2);
+
 /*!
  * @brief Returns true if this SYCL context is a host context.
  *
diff --git a/backends/include/dppl_sycl_queue_interface.h b/backends/include/dppl_sycl_queue_interface.h
@@ -44,6 +44,17 @@ DPPL_C_EXTERN_C_BEGIN
 DPPL_API
 void DPPLQueue_Delete (__dppl_take DPPLSyclQueueRef QRef);
 
+/*!
+ * @brief Checks if two DPPLSyclQueueRef objects point to the same sycl::queue.
+ *
+ * @param    QRef1          First opaque pointer to the sycl queue.
+ * @param    QRef2          Second opaque pointer to the sycl queue.
+ * @return   True if the underlying sycl::queue are same, false otherwise.
+ */
+DPPL_API
+bool DPPLQueue_AreEq (__dppl_keep const DPPLSyclQueueRef QRef1,
+                      __dppl_keep const DPPLSyclQueueRef QRef2);
+
 /*!
  * @brief Returns the Sycl backend for the provided sycl::queue.
  *
diff --git a/backends/source/dppl_sycl_context_interface.cpp b/backends/source/dppl_sycl_context_interface.cpp
@@ -36,6 +36,14 @@ namespace
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPPLSyclContextRef)
 } /* end of anonymous namespace */
 
+bool DPPLContext_AreEq (__dppl_keep const DPPLSyclContextRef CtxRef1,
+                        __dppl_keep const DPPLSyclContextRef CtxRef2)
+{
+    if(!(CtxRef1 && CtxRef2))
+        // \todo handle error
+        return false;
+    return (*unwrap(CtxRef1) == *unwrap(CtxRef2));
+}
 
 bool DPPLContext_IsHost (__dppl_keep const DPPLSyclContextRef CtxRef)
 {
diff --git a/backends/source/dppl_sycl_queue_interface.cpp b/backends/source/dppl_sycl_queue_interface.cpp
@@ -118,6 +118,16 @@ void DPPLQueue_Delete (__dppl_take DPPLSyclQueueRef QRef)
     delete unwrap(QRef);
 }
 
+
+bool DPPLQueue_AreEq (__dppl_keep const DPPLSyclQueueRef QRef1,
+                      __dppl_keep const DPPLSyclQueueRef QRef2)
+{
+    if(!(QRef1 && QRef2))
+        // \todo handle error
+        return false;
+    return (*unwrap(QRef1) == *unwrap(QRef2));
+}
+
 enum DPPLSyclBEType DPPLQueue_GetBackend (__dppl_keep DPPLSyclQueueRef QRef)
 {
     auto Q = unwrap(QRef);
diff --git a/backends/source/dppl_sycl_queue_manager.cpp b/backends/source/dppl_sycl_queue_manager.cpp
@@ -230,11 +230,7 @@ bool QMgrHelper::isCurrentQueue (__dppl_keep const DPPLSyclQueueRef QRef)
     }
     auto last = activated_q.size() - 1;
     auto currQ = activated_q[last];
-    auto currCtx = currQ.get_context();
-    auto currD = currQ.get_device();
-    auto InD = unwrap(QRef)->get_device();
-    auto InCtx = unwrap(QRef)->get_context();
-    return (currCtx == InCtx && currD == InD);
+    return (*unwrap(QRef) == currQ);
 }
 
 /*!
@@ -472,7 +468,7 @@ DPPLQueueMgr_SetAsDefaultQueue (enum DPPLSyclBEType BETy,
                                 enum DPPLSyclDeviceType DeviceTy,
                                 size_t DNum)
 {
-    QMgrHelper::setAsDefaultQueue(BETy, DeviceTy, DNum);
+    return QMgrHelper::setAsDefaultQueue(BETy, DeviceTy, DNum);
 }
 
 /*!
diff --git a/backends/tests/test_sycl_queue_interface.cpp b/backends/tests/test_sycl_queue_interface.cpp
@@ -87,6 +87,65 @@ struct TestDPPLSyclQueueInterface : public ::testing::Test
     {  }
 };
 
+TEST_F (TestDPPLSyclQueueInterface, CheckAreEq)
+{
+    auto Q1 = DPPLQueueMgr_GetCurrentQueue();
+    auto Q2 = DPPLQueueMgr_GetCurrentQueue();
+    EXPECT_TRUE(DPPLQueue_AreEq(Q1, Q2));
+
+    auto nOclGPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBEType::DPPL_OPENCL,
+                                             DPPLSyclDeviceType::DPPL_GPU);
+    auto nOclCPU = DPPLQueueMgr_GetNumQueues(DPPLSyclBEType::DPPL_OPENCL,
+                                             DPPLSyclDeviceType::DPPL_CPU);
+    {
+    if(!nOclGPU)
+        GTEST_SKIP_("No OpenCL GPUs available.\n");
+
+    auto Def_Q = DPPLQueueMgr_SetAsDefaultQueue(
+                    DPPLSyclBEType::DPPL_OPENCL,
+                    DPPLSyclDeviceType::DPPL_GPU,
+                    0
+                 );
+    auto OclGPU_Q0 = DPPLQueueMgr_PushQueue(
+                        DPPLSyclBEType::DPPL_OPENCL,
+                        DPPLSyclDeviceType::DPPL_GPU,
+                        0
+                    );
+    auto OclGPU_Q1 = DPPLQueueMgr_PushQueue(
+                        DPPLSyclBEType::DPPL_OPENCL,
+                        DPPLSyclDeviceType::DPPL_GPU,
+                        0
+                    );
+    EXPECT_TRUE(DPPLQueue_AreEq(Def_Q, OclGPU_Q0));
+    EXPECT_TRUE(DPPLQueue_AreEq(Def_Q, OclGPU_Q1));
+    EXPECT_TRUE(DPPLQueue_AreEq(OclGPU_Q0, OclGPU_Q1));
+    DPPLQueue_Delete(Def_Q);
+    DPPLQueue_Delete(OclGPU_Q0);
+    DPPLQueue_Delete(OclGPU_Q1);
+    DPPLQueueMgr_PopQueue();
+    DPPLQueueMgr_PopQueue();
+    }
+
+    {
+    if(!nOclGPU || !nOclCPU)
+        GTEST_SKIP_("OpenCL GPUs and CPU not available.\n");
+    auto GPU_Q = DPPLQueueMgr_PushQueue(
+                    DPPLSyclBEType::DPPL_OPENCL,
+                    DPPLSyclDeviceType::DPPL_GPU,
+                    0
+                );
+    auto CPU_Q = DPPLQueueMgr_PushQueue(
+                    DPPLSyclBEType::DPPL_OPENCL,
+                    DPPLSyclDeviceType::DPPL_CPU,
+                    0
+                );
+    EXPECT_FALSE(DPPLQueue_AreEq(GPU_Q, CPU_Q));
+    DPPLQueueMgr_PopQueue();
+    DPPLQueueMgr_PopQueue();
+    }
+
+}
+
 TEST_F (TestDPPLSyclQueueInterface, CheckGetBackend)
 {
     auto Q1 = DPPLQueueMgr_GetCurrentQueue();
@@ -101,16 +160,19 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetBackend)
         auto Q = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_GPU, 0);
         EXPECT_TRUE(DPPLQueue_GetBackend(Q) == DPPL_OPENCL);
         DPPLQueue_Delete(Q);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0);
         EXPECT_TRUE(DPPLQueue_GetBackend(Q) == DPPL_OPENCL);
         DPPLQueue_Delete(Q);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_LEVEL_ZERO, DPPL_GPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_LEVEL_ZERO, DPPL_GPU, 0);
         EXPECT_TRUE(DPPLQueue_GetBackend(Q) == DPPL_LEVEL_ZERO);
         DPPLQueue_Delete(Q);
+        DPPLQueueMgr_PopQueue();
     }
 }
 
@@ -128,20 +190,23 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetContext)
         ASSERT_TRUE(OclGpuCtx != nullptr);
         DPPLQueue_Delete(Q);
         DPPLContext_Delete(OclGpuCtx);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0);
         auto OclCpuCtx = DPPLQueue_GetContext(Q);
         ASSERT_TRUE(OclCpuCtx != nullptr);
         DPPLQueue_Delete(Q);
         DPPLContext_Delete(OclCpuCtx);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_LEVEL_ZERO, DPPL_GPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_LEVEL_ZERO, DPPL_GPU, 0);
         auto L0Ctx = DPPLQueue_GetContext(Q);
         ASSERT_TRUE(Ctx != nullptr);
         DPPLQueue_Delete(Q);
         DPPLContext_Delete(L0Ctx);
+        DPPLQueueMgr_PopQueue();
     }
 }
 
@@ -160,6 +225,7 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetDevice)
         EXPECT_TRUE(DPPLDevice_IsGPU(OCLGPU_D));
         DPPLQueue_Delete(Q);
         DPPLDevice_Delete(OCLGPU_D);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_OPENCL, DPPL_CPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_OPENCL, DPPL_CPU, 0);
@@ -168,6 +234,7 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetDevice)
         EXPECT_TRUE(DPPLDevice_IsCPU(OCLCPU_D));
         DPPLQueue_Delete(Q);
         DPPLDevice_Delete(OCLCPU_D);
+        DPPLQueueMgr_PopQueue();
     }
     if(DPPLQueueMgr_GetNumQueues(DPPL_LEVEL_ZERO, DPPL_GPU)) {
         auto Q = DPPLQueueMgr_PushQueue(DPPL_LEVEL_ZERO, DPPL_GPU, 0);
@@ -176,6 +243,7 @@ TEST_F (TestDPPLSyclQueueInterface, CheckGetDevice)
         EXPECT_TRUE(DPPLDevice_IsGPU(L0GPU_D));
         DPPLQueue_Delete(Q);
         DPPLDevice_Delete(L0GPU_D);
+        DPPLQueueMgr_PopQueue();
     }
 }
 
diff --git a/dpctl/_sycl_core.pxd b/dpctl/_sycl_core.pxd
@@ -37,6 +37,7 @@ cdef class SyclContext:
 
     @staticmethod
     cdef SyclContext _create (DPPLSyclContextRef ctxt)
+    cpdef bool equals (self, SyclContext ctxt)
     cdef DPPLSyclContextRef get_context_ref (self)
 
 
@@ -108,6 +109,7 @@ cdef class SyclQueue:
 
     @staticmethod
     cdef  SyclQueue _create (DPPLSyclQueueRef qref)
+    cpdef bool equals (self, SyclQueue q)
     cpdef SyclContext get_sycl_context (self)
     cpdef SyclDevice get_sycl_device (self)
     cdef  DPPLSyclQueueRef get_queue_ref (self)
diff --git a/dpctl/backend.pxd b/dpctl/backend.pxd
@@ -125,6 +125,8 @@ cdef extern from "dppl_sycl_platform_interface.h":
 
 
 cdef extern from "dppl_sycl_context_interface.h":
+    cdef bool DPPLContext_AreEq (const DPPLSyclContextRef CtxRef1,
+                                 const DPPLSyclContextRef CtxRef2)
     cdef DPPLSyclBEType DPPLContext_GetBackend (const DPPLSyclContextRef CtxRef)
     cdef void DPPLContext_Delete (DPPLSyclContextRef CtxRef)
 
@@ -146,6 +148,8 @@ cdef extern from "dppl_sycl_program_interface.h":
 
 
 cdef extern from "dppl_sycl_queue_interface.h":
+    cdef bool DPPLQueue_AreEq (const DPPLSyclQueueRef QRef1,
+                               const DPPLSyclQueueRef QRef2)
     cdef void DPPLQueue_Delete (DPPLSyclQueueRef QRef)
     cdef DPPLSyclBEType DPPLQueue_GetBackend (const DPPLSyclQueueRef Q)
     cdef DPPLSyclContextRef DPPLQueue_GetContext (const DPPLSyclQueueRef Q)
diff --git a/dpctl/sycl_core.pyx b/dpctl/sycl_core.pyx
@@ -96,6 +96,12 @@ cdef class SyclContext:
     def __dealloc__ (self):
         DPPLContext_Delete(self._ctxt_ref)
 
+    cpdef bool equals (self, SyclContext ctxt):
+        """ Returns true if the SyclContext argument has the same _context_ref
+            as this SyclContext.
+        """
+        return DPPLContext_AreEq(self._ctxt_ref, ctxt.get_context_ref())
+
     cdef DPPLSyclContextRef get_context_ref (self):
         return self._ctxt_ref
 
@@ -338,6 +344,12 @@ cdef class SyclQueue:
 
         return ret
 
+    cpdef bool equals (self, SyclQueue q):
+        """ Returns true if the SyclQueue argument has the same _queue_ref
+            as this SycleQueue.
+        """
+        return DPPLQueue_AreEq(self._queue_ref, q.get_queue_ref())
+
     def get_sycl_backend (self):
         """ Returns the Sycl bakend associated with the queue.
         """
diff --git a/dpctl/tests/__init__.py b/dpctl/tests/__init__.py
@@ -25,6 +25,7 @@
 from .test_dump_functions import *
 from .test_sycl_kernel_submit import *
 from .test_sycl_program import *
+from .test_sycl_queue import *
 from .test_sycl_queue_manager import *
 from .test_sycl_queue_memcpy import *
 from .test_sycl_usm import *
diff --git a/dpctl/tests/test_sycl_queue.py b/dpctl/tests/test_sycl_queue.py
@@ -0,0 +1,41 @@
+##===------------- test_sycl_queue.py - dpctl  -------*- Python -*---------===##
+##
+##                      Data Parallel Control (dpctl)
+##
+## Copyright 2020 Intel Corporation
+##
+## Licensed under the Apache License, Version 2.0 (the "License");
+## you may not use this file except in compliance with the License.
+## You may obtain a copy of the License at
+##
+##    http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+##
+##===----------------------------------------------------------------------===##
+##
+## \file
+## Defines unit test cases for the SyclQueue classes defined in sycl_core.pyx.
+##===----------------------------------------------------------------------===##
+
+import dpctl
+import unittest
+
+@unittest.skipUnless(dpctl.has_gpu_queues(), "No OpenCL GPU queues available")
+@unittest.skipUnless(dpctl.has_cpu_queues(), "No OpenCL GPU queues available")
+class TestSyclQueue (unittest.TestCase):
+
+    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))
+            with dpctl.device_context("opencl:cpu") as cpuQ:
+                self.assertFalse(cpuQ.equals(gpuQ0))
+
+
+if __name__ == '__main__':
+    unittest.main()

Original file line number	Diff line number	Diff line change
`@@ -230,11 +230,7 @@ bool QMgrHelper::isCurrentQueue (__dppl_keep const DPPLSyclQueueRef QRef)`
`230`	`230`	`}`
`231`	`231`	`auto last = activated_q.size() - 1;`
`232`	`232`	`auto currQ = activated_q[last];`
`233`		`- auto currCtx = currQ.get_context();`
`234`		`- auto currD = currQ.get_device();`
`235`		`- auto InD = unwrap(QRef)->get_device();`
`236`		`- auto InCtx = unwrap(QRef)->get_context();`
`237`		`- return (currCtx == InCtx && currD == InD);`
	`233`	`+ return (*unwrap(QRef) == currQ);`
`238`	`234`	`}`
`239`	`235`
`240`	`236`	`/*!`
`@@ -472,7 +468,7 @@ DPPLQueueMgr_SetAsDefaultQueue (enum DPPLSyclBEType BETy,`
`472`	`468`	`enum DPPLSyclDeviceType DeviceTy,`
`473`	`469`	`size_t DNum)`
`474`	`470`	`{`
`475`		`- QMgrHelper::setAsDefaultQueue(BETy, DeviceTy, DNum);`
	`471`	`+ return QMgrHelper::setAsDefaultQueue(BETy, DeviceTy, DNum);`
`476`	`472`	`}`
`477`	`473`
`478`	`474`	`/*!`