Implementation of memset function in libSyclInterface (#812)

Author: vlad-perevezentsev

libsyclinterface/include/dpctl_sycl_queue_interface.h

@@ -385,4 +385,21 @@ DPCTLSyclEventRef DPCTLQueue_SubmitBarrierForEvents(
     __dpctl_keep const DPCTLSyclEventRef *DepEvents,
     size_t NDepEvents);
 
+/*!
+ * @brief C-API wrapper for ``sycl::queue::memset``.
+ *
+ * @param    QRef           An opaque pointer to the ``sycl::queue``.
+ * @param    USMRef         An USM pointer to the memory to fill.
+ * @param    Value          A value to fill.
+ * @param    Count          A number of uint8_t elements to fill.
+ * @return   An opaque pointer to the ``sycl::event`` returned by the
+ *           ``sycl::queue::fill`` function.
+ * @ingroup QueueInterface
+ */
+DPCTL_API
+DPCTLSyclEventRef DPCTLQueue_Memset(__dpctl_keep const DPCTLSyclQueueRef QRef,
+                                    void *USMRef,
+                                    uint8_t Value,
+                                    size_t Count);
+
 DPCTL_C_EXTERN_C_END

libsyclinterface/source/dpctl_sycl_queue_interface.cpp

@@ -612,3 +612,26 @@ DPCTLQueue_SubmitBarrier(__dpctl_keep const DPCTLSyclQueueRef QRef)
 {
     return DPCTLQueue_SubmitBarrierForEvents(QRef, nullptr, 0);
 }
+
+DPCTLSyclEventRef DPCTLQueue_Memset(__dpctl_keep const DPCTLSyclQueueRef QRef,
+                                    void *USMRef,
+                                    uint8_t Value,
+                                    size_t Count)
+{
+    auto Q = unwrap(QRef);
+    if (Q && USMRef) {
+        sycl::event ev;
+        try {
+            ev = Q->memset(USMRef, static_cast<int>(Value), Count);
+        } catch (std::exception const &e) {
+            error_handler(e, __FILE__, __func__, __LINE__);
+            return nullptr;
+        }
+        return wrap(new event(ev));
+    }
+    else {
+        error_handler("QRef or USMRef passed to fill8 were NULL.", __FILE__,
+                      __func__, __LINE__);
+        return nullptr;
+    }
+}

libsyclinterface/tests/test_sycl_queue_interface.cpp

@@ -32,6 +32,7 @@
 #include "dpctl_sycl_event_interface.h"
 #include "dpctl_sycl_queue_interface.h"
 #include "dpctl_sycl_queue_manager.h"
+#include "dpctl_sycl_usm_interface.h"
 #include <CL/sycl.hpp>
 #include <gtest/gtest.h>
 
@@ -407,6 +408,51 @@ TEST_P(TestDPCTLQueueMemberFunctions, CheckMemOpsNullPtr)
     }
 }
 
+TEST(TestDPCTLSyclQueueInterface, CheckMemsetNullQRef)
+{
+    DPCTLSyclQueueRef QRef = nullptr;
+    void *p = nullptr;
+    uint8_t val8 = 0;
+    DPCTLSyclEventRef ERef = nullptr;
+
+    ASSERT_NO_FATAL_FAILURE(ERef = DPCTLQueue_Memset(QRef, p, val8, 1));
+    ASSERT_FALSE(bool(ERef));
+}
+
+TEST_P(TestDPCTLQueueMemberFunctions, CheckMemset)
+{
+    DPCTLSyclUSMRef p = nullptr;
+    DPCTLSyclEventRef ERef = nullptr;
+    uint8_t val = 73;
+    size_t nbytes = 256;
+    uint8_t *host_arr = new uint8_t[nbytes];
+
+    ASSERT_FALSE(host_arr == nullptr);
+
+    ASSERT_NO_FATAL_FAILURE(p = DPCTLmalloc_device(nbytes, QRef));
+    ASSERT_FALSE(p == nullptr);
+
+    ASSERT_NO_FATAL_FAILURE(
+        ERef = DPCTLQueue_Memset(QRef, (void *)p, val, nbytes));
+    ASSERT_NO_FATAL_FAILURE(DPCTLEvent_Wait(ERef));
+    ASSERT_NO_FATAL_FAILURE(DPCTLEvent_Delete(ERef));
+
+    ERef = nullptr;
+
+    ASSERT_NO_FATAL_FAILURE(ERef =
+                                DPCTLQueue_Memcpy(QRef, host_arr, p, nbytes));
+    ASSERT_NO_FATAL_FAILURE(DPCTLEvent_Wait(ERef));
+    ASSERT_NO_FATAL_FAILURE(DPCTLEvent_Delete(ERef));
+
+    ASSERT_NO_FATAL_FAILURE(DPCTLfree_with_queue(p, QRef));
+
+    bool equal = true;
+    for (size_t i = 0; i < nbytes; ++i) {
+        ASSERT_TRUE(host_arr[i] == val);
+    }
+    delete[] host_arr;
+}
+
 INSTANTIATE_TEST_SUITE_P(
     DPCTLQueueMemberFuncTests,
     TestDPCTLQueueMemberFunctions,