Implementing USM memory management (#34)

* Add initial version of _memory.pyx

* Import setuptools before Cython. Otherwise, both might disagree about the class to use.

* Add dppl._memory Cython module.

* Run dppl/tests/dppl_tests too when run all unit tests.

* Add tests for memory manager.

* Split tests for memory. One test one context (no, CPU, GPU).

* [opt] Rename getpyexts() to extensions().

* Adds C and Cython API for portions of Sycl queue, device, context interfaces.

     - Separates out the queue manager from the sycl queue interface wrapper.
     - Added API to get context, device froma  Sycl queue.
     - Added C-API wrappers for sycl device, queue, context interfaces exposing
       some of the API functionalities. More can be added as needed.
     - The dppl extension now defines extension types for sycl quque, device, context to
       mimic the C API.
     - Sycl queues are now returned to callers as a SyclQueue extension type rather than
       a Py_capsule.

* Add C-API stub library for sycl memory.

* Add missing DPPL_API.

* Move platform specific functions into a separate file.

* Create a single utility function to delete C strings.

* Update backends/source/dppl_utils.cpp

New line at EOF.

* Add _sycl_core.pxd file.

* Remove using of PyCapsule in _memory.pyx.

* Small style fixes in _memory.pyx.

* Moved functions from _memory.pyx to C-API interface library.

* Move Cython definitions for backend to single pxd file.

* Remove SyclQueue from _memory.pyx

* Use SyclQueue from

* Remove cl::sycl::queue from _memory.pyx

* Removed commented code from _memory.pyx

* Eliminate temporary context object.

* Fix style.

* Add MemoryUSM* classes.

* Add __getbuffer__ to Shared and Host MemoryUSM classes.

* Rename C-API types for USM.

* Add DPPLUSM_GetPointerType and remove types from CL/sycl.hpp from _memory.pyx

* Clean unused code from _memory_.pyx

* Small fixes.

* Remove unused code.

* Fix style.

* Fix style

* Use wrap().

* Store context instead of queue in Memory class.

* Pass queue as parameter to constructor. If queue is None then get dppl current queue.

* Add comment about casting memory_ptr to char*.

* Remove pointer property from Memory.

* Rename file with usm tests.

Co-authored-by: Diptorup Deb <diptorup@cs.unc.edu>

Author: PokhodenkoSA

backends/CMakeLists.txt

@@ -101,6 +101,7 @@ add_library(
   source/dppl_sycl_platform_interface.cpp
   source/dppl_sycl_queue_interface.cpp
   source/dppl_sycl_queue_manager.cpp
+  source/dppl_sycl_usm_interface.cpp
   source/dppl_utils.cpp
 )
 

backends/include/dppl_sycl_types.h

@@ -55,3 +55,10 @@ typedef struct DPPLOpaqueSyclQueue *DPPLSyclQueueRef;
  *
  */
 typedef struct DPPLOpaqueSyclProgram *DPPLSyclProgramRef;
+
+/*!
+ * @brief Used to pass a sycl::usm memory opaquely through DPPL interfaces.
+ *
+ * @see sycl::usm
+ */
+typedef struct DPPLOpaqueSyclUSM *DPPLSyclUSMRef;

backends/include/dppl_sycl_usm_interface.h

@@ -0,0 +1,89 @@
+//===--- dppl_sycl_usm_interface.h - DPPL-SYCL interface ---*---C++ -*---===//
+//
+//               Python Data Parallel Processing Library (PyDPPL)
+//
+// 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 header declares a C interface to sycl::usm interface functions.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "dppl_data_types.h"
+#include "dppl_sycl_types.h"
+#include "Support/DllExport.h"
+#include "Support/ExternC.h"
+#include "Support/MemOwnershipAttrs.h"
+
+DPPL_C_EXTERN_C_BEGIN
+
+/*!
+ * @brief Crete USM shared memory.
+ *
+ * @return The pointer to USM shared memory.
+ */
+DPPL_API
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_shared (size_t size, __dppl_keep const DPPLSyclQueueRef QRef);
+
+/*!
+ * @brief Crete USM host memory.
+ *
+ * @return The pointer to USM host memory.
+ */
+DPPL_API
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_host (size_t size, __dppl_keep const DPPLSyclQueueRef QRef);
+
+/*!
+ * @brief Crete USM device memory.
+ *
+ * @return The pointer to USM device memory.
+ */
+DPPL_API
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_device (size_t size, __dppl_keep const DPPLSyclQueueRef QRef);
+
+/*!
+ * @brief Free USM memory.
+ *
+ */
+DPPL_API
+void DPPLfree_with_queue (__dppl_take DPPLSyclUSMRef MRef,
+                          __dppl_keep const DPPLSyclQueueRef QRef);
+
+/*!
+ * @brief Free USM memory.
+ *
+ */
+DPPL_API
+void DPPLfree_with_context (__dppl_take DPPLSyclUSMRef MRef,
+                            __dppl_keep const DPPLSyclContextRef CRef);
+
+/*!
+ * @brief Get pointer type.
+ *
+ * @return "host", "device", "shared" or "unknown"
+ */
+DPPL_API
+const char *
+DPPLUSM_GetPointerType (__dppl_keep const DPPLSyclUSMRef MRef,
+                        __dppl_keep const DPPLSyclContextRef СRef);
+
+DPPL_C_EXTERN_C_END

backends/source/dppl_sycl_usm_interface.cpp

@@ -0,0 +1,101 @@
+//===--- dppl_sycl_usm_interface.cpp - DPPL-SYCL interface --*- C++ -*---===//
+//
+//               Python Data Parallel Processing Library (PyDPPL)
+//
+// 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 implements the data types and functions declared in
+/// dppl_sycl_usm_interface.h.
+///
+//===----------------------------------------------------------------------===//
+
+#include "dppl_sycl_usm_interface.h"
+#include "Support/CBindingWrapping.h"
+
+#include <CL/sycl.hpp>                /* SYCL headers   */
+
+using namespace cl::sycl;
+
+namespace
+{
+// Create wrappers for C Binding types (see CBindingWrapping.h).
+ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(queue, DPPLSyclQueueRef)
+ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPPLSyclContextRef)
+ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(void, DPPLSyclUSMRef)
+
+} /* end of anonymous namespace */
+
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_shared (size_t size, __dppl_keep const DPPLSyclQueueRef QRef)
+{
+    auto Q = unwrap(QRef);
+    auto Ptr = malloc_shared(size, *Q);
+    return wrap(Ptr);
+}
+
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_host (size_t size, __dppl_keep const DPPLSyclQueueRef QRef)
+{
+    auto Q = unwrap(QRef);
+    auto Ptr = malloc_host(size, *Q);
+    return wrap(Ptr);
+}
+
+__dppl_give DPPLSyclUSMRef
+DPPLmalloc_device (size_t size, __dppl_keep const DPPLSyclQueueRef QRef)
+{
+    auto Q = unwrap(QRef);
+    auto Ptr = malloc_device(size, *Q);
+    return wrap(Ptr);
+}
+
+void DPPLfree_with_queue (__dppl_take DPPLSyclUSMRef MRef,
+                          __dppl_keep const DPPLSyclQueueRef QRef)
+{
+    auto Ptr = unwrap(MRef);
+    auto Q = unwrap(QRef);
+    free(Ptr, *Q);
+}
+
+void DPPLfree_with_context (__dppl_take DPPLSyclUSMRef MRef,
+                            __dppl_keep const DPPLSyclContextRef СRef)
+{
+    auto Ptr = unwrap(MRef);
+    auto C = unwrap(СRef);
+    free(Ptr, *C);
+}
+
+const char *
+DPPLUSM_GetPointerType (__dppl_keep const DPPLSyclUSMRef MRef,
+                        __dppl_keep const DPPLSyclContextRef CRef)
+{
+    auto Ptr = unwrap(MRef);
+    auto C = unwrap(CRef);
+
+    auto kind = get_pointer_type(Ptr, *C);
+    switch(kind) {
+        case usm::alloc::host:
+            return "host";
+        case usm::alloc::device:
+            return "device";
+        case usm::alloc::shared:
+            return "shared";
+        default:
+            return "unknown";
+    }
+}

dppl/_memory.pyx

@@ -0,0 +1,105 @@
+import dppl
+from dppl.backend cimport *
+from ._sycl_core cimport SyclContext, SyclQueue
+
+from cpython cimport Py_buffer
+
+
+cdef class Memory:
+    cdef DPPLSyclUSMRef memory_ptr
+    cdef Py_ssize_t nbytes
+    cdef SyclContext context
+
+    cdef _cinit(self, Py_ssize_t nbytes, ptr_type, SyclQueue queue):
+        cdef DPPLSyclUSMRef p
+
+        self.memory_ptr = NULL
+        self.nbytes = 0
+        self.context = None
+
+        if (nbytes > 0):
+            if queue is None:
+                queue = dppl.get_current_queue()
+
+            if (ptr_type == "shared"):
+                p = DPPLmalloc_shared(nbytes, queue.get_queue_ref())
+            elif (ptr_type == "host"):
+                p = DPPLmalloc_host(nbytes, queue.get_queue_ref())
+            elif (ptr_type == "device"):
+                p = DPPLmalloc_device(nbytes, queue.get_queue_ref())
+            else:
+                raise RuntimeError("Pointer type is unknown: {}" \
+                    .format(ptr_type))
+
+            if (p):
+                self.memory_ptr = p
+                self.nbytes = nbytes
+                self.context = queue.get_sycl_context()
+            else:
+                raise RuntimeError("Null memory pointer returned")
+        else:
+            raise ValueError("Non-positive number of bytes found.")
+
+    def __dealloc__(self):
+        if (self.memory_ptr):
+            DPPLfree_with_context(self.memory_ptr,
+                                  self.context.get_context_ref())
+        self.memory_ptr = NULL
+        self.nbytes = 0
+        self.context = None
+
+    cdef _getbuffer(self, Py_buffer *buffer, int flags):
+        # memory_ptr is Ref which is pointer to SYCL type. For USM it is void*.
+        buffer.buf = <char *>self.memory_ptr
+        buffer.format = 'B'                     # byte
+        buffer.internal = NULL                  # see References
+        buffer.itemsize = 1
+        buffer.len = self.nbytes
+        buffer.ndim = 1
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = &self.nbytes
+        buffer.strides = &buffer.itemsize
+        buffer.suboffsets = NULL                # for pointer arrays only
+
+    property nbytes:
+        def __get__(self):
+            return self.nbytes
+
+    property _context:
+        def __get__(self):
+            return self.context
+
+    def __repr__(self):
+        return "<Intel(R) USM allocated memory block of {} bytes at {}>" \
+            .format(self.nbytes, hex(<object>(<Py_ssize_t>self.memory_ptr)))
+
+    def _usm_type(self):
+        cdef const char* kind
+        kind = DPPLUSM_GetPointerType(self.memory_ptr,
+                                      self.context.get_context_ref())
+        return kind.decode('UTF-8')
+
+
+cdef class MemoryUSMShared(Memory):
+
+    def __cinit__(self, Py_ssize_t nbytes, SyclQueue queue=None):
+        self._cinit(nbytes, "shared", queue)
+
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        self._getbuffer(buffer, flags)
+
+
+cdef class MemoryUSMHost(Memory):
+
+    def __cinit__(self, Py_ssize_t nbytes, SyclQueue queue=None):
+        self._cinit(nbytes, "host", queue)
+
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        self._getbuffer(buffer, flags)
+
+
+cdef class MemoryUSMDevice(Memory):
+
+    def __cinit__(self, Py_ssize_t nbytes, SyclQueue queue=None):
+        self._cinit(nbytes, "device", queue)

dppl/_sycl_core.pxd

@@ -0,0 +1,61 @@
+##===------------- sycl_core.pxd - DPPL interface ------*- Cython -*-------===##
+##
+##               Python Data Parallel Processing Library (PyDPPL)
+##
+## 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 defines the Cython interface for the Sycl API of PyDPPL.
+##
+##===----------------------------------------------------------------------===##
+
+from .backend cimport *
+
+
+cdef class SyclContext:
+    ''' Wrapper class for a Sycl Context
+    '''
+    cdef DPPLSyclContextRef ctxt_ptr
+
+    @staticmethod
+    cdef SyclContext _create (DPPLSyclContextRef ctxt)
+    cdef DPPLSyclContextRef get_context_ref (self)
+
+
+cdef class SyclDevice:
+    ''' Wrapper class for a Sycl Device
+    '''
+    cdef DPPLSyclDeviceRef device_ptr
+    cdef const char *vendor_name
+    cdef const char *device_name
+    cdef const char *driver_version
+
+    @staticmethod
+    cdef SyclDevice _create (DPPLSyclDeviceRef dref)
+    cdef DPPLSyclDeviceRef get_device_ptr (self)
+
+
+cdef class SyclQueue:
+    ''' Wrapper class for a Sycl queue.
+    '''
+    cdef DPPLSyclQueueRef queue_ptr
+
+    @staticmethod
+    cdef SyclQueue _create (DPPLSyclQueueRef qref)
+    cpdef SyclContext get_sycl_context (self)
+    cpdef SyclDevice get_sycl_device (self)
+    cdef DPPLSyclQueueRef get_queue_ref (self)