Introduced tests/test_sycl_usm_interface.cpp

Added DPPLDevice_AreEq to check if two devices are pointer equal.
Used in the test.

Author: oleksandr-pavlyk

backends/include/dppl_sycl_device_interface.h

@@ -133,4 +133,15 @@ DPPLDevice_GetVendorName (__dppl_keep const DPPLSyclDeviceRef DRef);
 DPPL_API
 bool DPPLDevice_IsHostUnifiedMemory (__dppl_keep const DPPLSyclDeviceRef DRef);
 
+/*!
+ * @brief Checks if two DPPLSyclDeviceRef objects point to the same
+ * sycl::device.
+ *
+ * @param    DevRef1       First opaque pointer to the sycl device.
+ * @param    DevRef2       Second opaque pointer to the sycl device.
+ * @return   True if the underlying sycl::device are same, false otherwise.
+ */
+DPPL_API
+bool DPPLDevice_AreEq (__dppl_keep const DPPLSyclDeviceRef DevRef1,
+                        __dppl_keep const DPPLSyclDeviceRef DevRef2);
 DPPL_C_EXTERN_C_END

backends/source/dppl_sycl_device_interface.cpp

@@ -153,3 +153,12 @@ bool DPPLDevice_IsHostUnifiedMemory (__dppl_keep const DPPLSyclDeviceRef DRef)
 {
     return unwrap(DRef)->get_info<info::device::host_unified_memory>();
 }
+
+bool DPPLDevice_AreEq(__dppl_keep const DPPLSyclDeviceRef DevRef1,
+		      __dppl_keep const DPPLSyclDeviceRef DevRef2)
+{
+    if(!(DevRef1 && DevRef2))
+        // \todo handle error
+        return false;
+    return (*unwrap(DevRef1) == *unwrap(DevRef2));
+}

backends/tests/CMakeLists.txt

@@ -28,6 +28,7 @@ else()
     test_sycl_program_interface
     test_sycl_queue_interface
     test_sycl_queue_manager
+    test_sycl_usm_interface
   )
 
   # Copy the spir-v input files to test build directory

backends/tests/test_sycl_usm_interface.cpp

@@ -0,0 +1,181 @@
+//===-------- test_sycl_usm_interface.cpp - dpctl-C_API ---*--- C++ --*--===//
+//
+//               Data Parallel Control Library (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
+/// This file has unit test cases for functions defined in
+/// dppl_sycl_usm_interface.h.
+///
+//===----------------------------------------------------------------------===//
+
+#include "dppl_sycl_context_interface.h"
+#include "dppl_sycl_device_interface.h"
+#include "dppl_sycl_event_interface.h"
+#include "dppl_sycl_queue_interface.h"
+#include "dppl_sycl_queue_manager.h"
+#include "dppl_sycl_usm_interface.h"
+#include "Support/CBindingWrapping.h"
+#include <CL/sycl.hpp>
+#include <gtest/gtest.h>
+
+using namespace cl::sycl;
+
+namespace
+{
+constexpr size_t SIZE = 1024;
+
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(void, DPPLSyclUSMRef);
+
+bool has_devices ()
+{
+    bool ret = false;
+    for (auto &p : platform::get_platforms()) {
+        if (p.is_host())
+            continue;
+        if(!p.get_devices().empty()) {
+            ret = true;
+            break;
+        }
+    }
+    return ret;
+}
+
+void common_test_body(size_t nbytes, const DPPLSyclUSMRef Ptr, const DPPLSyclQueueRef Q, const char *expected) {
+
+    auto Ctx = DPPLQueue_GetContext(Q);
+
+    auto kind = DPPLUSM_GetPointerType(Ptr, Ctx);
+    EXPECT_TRUE(0 == std::strncmp(kind, expected, 4));
+
+    auto Dev = DPPLUSM_GetPointerDevice(Ptr, Ctx);
+    auto QueueDev = DPPLQueue_GetDevice(Q);
+    EXPECT_TRUE(DPPLDevice_AreEq(Dev, QueueDev));
+
+    DPPLQueue_Prefetch(Q, Ptr, nbytes);
+}
+    
+}
+
+struct TestDPPLSyclUSMInterface : public ::testing::Test
+{
+
+    TestDPPLSyclUSMInterface ()
+    {  }
+
+    ~TestDPPLSyclUSMInterface ()
+    {  }
+};
+
+TEST_F(TestDPPLSyclUSMInterface, MallocShared)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLmalloc_shared(nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "shared");
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+TEST_F(TestDPPLSyclUSMInterface, MallocDevice)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLmalloc_device(nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "device");	
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+TEST_F(TestDPPLSyclUSMInterface, MallocHost)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLmalloc_host(nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "host");
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+TEST_F(TestDPPLSyclUSMInterface, AlignedAllocShared)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLaligned_alloc_shared(64, nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "shared");
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+TEST_F(TestDPPLSyclUSMInterface, AlignedAllocDevice)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLaligned_alloc_device(64, nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "device");
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+TEST_F(TestDPPLSyclUSMInterface, AlignedAllocHost)
+{
+    if (!has_devices())
+	GTEST_SKIP_("Skipping: No Sycl Devices.\n");
+
+    auto Q = DPPLQueueMgr_GetCurrentQueue();
+    const size_t nbytes = 1024;
+
+    auto Ptr = DPPLaligned_alloc_host(64, nbytes, Q);
+    EXPECT_TRUE(bool(Ptr));
+
+    common_test_body(nbytes, Ptr, Q, "host");
+    DPPLfree_with_queue(Ptr, Q);
+}
+
+int
+main (int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    int ret = RUN_ALL_TESTS();
+    return ret;
+}