Dppl queue manager (#22)

Refactored API to expose a minimal sycl::queue interface.

* Uses a clean C-API
* The DPPL stack to keep track of activated sycl::queue objects is not thread local
* The code has more documentation and comments.

Author: diptorupd

backends/CMakeLists.txt

@@ -93,14 +93,10 @@ set(OpenCL_LIBRARY "${DPCPP_ROOT}/lib/libOpenCL.so")
 message(STATUS "OpenCL_INCLUDE_DIR: ${OpenCL_INCLUDE_DIR}")
 message(STATUS "OpenCL_LIBRARY: ${OpenCL_LIBRARY}")
 
-# Todo : Add build rules for unit tests
-
-# Todo : Add build rules for doxygen
-
 add_library(
   DPPLSyclInterface
   SHARED
-  source/dppl_sycl_interface.cpp
+  source/dppl_sycl_queue_interface.cpp
 )
 
 # Install DPPLOpenCLInterface
@@ -174,3 +170,15 @@ file(GLOB HEADERS "${CMAKE_SOURCE_DIR}/include/*.h*")
 foreach(HEADER ${HEADERS})
   install(FILES "${HEADER}" DESTINATION include)
 endforeach()
+
+# Install all headers in include/Support
+file(GLOB HEADERS "${CMAKE_SOURCE_DIR}/include/Support/*.h*")
+foreach(HEADER ${HEADERS})
+  install(FILES "${HEADER}" DESTINATION include/Support)
+endforeach()
+
+# Enable to build the PyDPPL backend test cases
+add_subdirectory(tests)
+
+# Todo : Add build rules for doxygen
+# maybe refer https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/

backends/dbg_build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set +xe
+rm -rf build
+mkdir build
+pushd build
+
+INSTALL_PREFIX=`pwd`/../install
+export ONEAPI_ROOT=/opt/intel/oneapi
+DPCPP_ROOT=${ONEAPI_ROOT}/compiler/latest/linux
+PYTHON_INC=`python -c "import distutils.sysconfig;                  \
+                        print(distutils.sysconfig.get_python_inc())"`
+NUMPY_INC=`python -c "import numpy; print(numpy.get_include())"`
+
+cmake                                                       \
+    -DCMAKE_BUILD_TYPE=Debug                                \
+    -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}                \
+    -DCMAKE_PREFIX_PATH=${INSTALL_PREFIX}                   \
+    -DDPCPP_ROOT=${DPCPP_ROOT}                              \
+    -DCMAKE_C_COMPILER:PATH=${DPCPP_ROOT}/bin/clang         \
+    -DCMAKE_CXX_COMPILER:PATH=${DPCPP_ROOT}/bin/dpcpp       \
+    -DPYTHON_INCLUDE_DIR=${PYTHON_INC}                      \
+    -DNUMPY_INCLUDE_DIR=${NUMPY_INC}                        \
+    -DGTEST_INCLUDE_DIR=${CONDA_PREFIX}/include/            \
+    -DGTEST_LIB_DIR=${CONDA_PREFIX}/lib                     \
+    ..
+
+make V=1 -n -j 4
+make check
+make install
+
+
+popd

backends/include/Support/CBindingWrapping.h

@@ -0,0 +1,45 @@
+//===----- Support/CBindingWrapping.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 file declares the wrapping macros for the DPPL C interface.
+///
+//===----------------------------------------------------------------------===//
+
+ #pragma once
+
+ #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)     \
+   inline ty *unwrap(ref P) {                            \
+     return reinterpret_cast<ty*>(P);                    \
+   }                                                     \
+                                                         \
+   inline ref wrap(const ty *P) {                        \
+     return reinterpret_cast<ref>(const_cast<ty*>(P));   \
+   }
+
+ #define DEFINE_STDCXX_CONVERSION_FUNCTIONS(ty, ref)     \
+   DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)           \
+                                                         \
+   template<typename T>                                  \
+   inline T *unwrap(ref P) {                             \
+     T *Q = (T*)unwrap(P);                               \
+     assert(Q && "Invalid cast!");                       \
+     return Q;                                           \
+   }

backends/include/Support/DllExport.h

@@ -0,0 +1,36 @@
+//===---------- Support/DllExport.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 file defines a "__declspec(dllexport)" wrapper for windows.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#ifdef _WIN32
+#    ifdef DPPLSyclInterface_EXPORTS
+#        define DPPL_API __declspec(dllexport)
+#    else
+#        define DPPL_API __declspec(dllimport)
+#    endif
+#else
+#    define DPPL_API
+#endif

backends/include/dppl_error_codes.hpp renamed to backends/include/Support/ExternC.h

@@ -1,4 +1,4 @@
-//===------- dppl_error_codes.hpp - DPPL-SYCL interface ---*- C++ -*-------===//
+//===------------ Support/ExternC.h - DPPL-SYCL interface ---*--- C ---*---===//
 //
 //               Python Data Parallel Processing Library (PyDPPL)
 //
@@ -19,20 +19,16 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file contains the error codes that are returned by DPPL functions.
+/// This file defines an extern "C" wrapper.
 ///
 //===----------------------------------------------------------------------===//
-#pragma once
-
-#include <cstdint>
 
-namespace dppl
-{
-
-enum : int64_t
-{
-    DPPL_FAILURE = -1,
-    DPPL_SUCCESS
-};
+#pragma once
 
-}
+#ifdef __cplusplus
+#define DPPL_C_EXTERN_C_BEGIN  extern "C" {
+#define DPPL_C_EXTERN_C_END    }
+#else
+#define DPPL_C_EXTERN_C_BEGIN
+#define DPPL_C_EXTERN_C_END
+#endif

backends/include/Support/MemOwnershipAttrs.h

@@ -0,0 +1,85 @@
+//===----- dppl_mem_ownership_attrs.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 file defines a group of macros that serve as attributes indicating the
+/// type of ownership of a pointer. The macros are modeled after similar
+/// attributes defines in Integer Set Library (isl) and serve the purpose of
+/// helping a programmer understand the semantics of a DPPL function.
+///
+//===----------------------------------------------------------------------===//
+#pragma once
+
+/**
+ * @defgroup MEM_MGMT_ATTR_MACROS Memory management attributes.
+ *
+ * @{
+ */
+
+/*!
+ * @def __dppl_give
+ * @brief The __dppl_give attribute indicates that a new object is returned and
+ * the caller now owns the object.
+ *
+ * The __dppl_give attribute informs a user that the function is allocating a
+ * new object and returning it to the user. The user now owns the object and to
+ * free the object, he/she should make sure to use it exactly once as a value
+ * for a __dppl_take argument. However, the user is free to use the object as
+ * he/she likes as a value to __dppl_keep arguments.
+ *
+ */
+#ifndef __dppl_give
+#define __dppl_give
+#endif
+/*!
+ * @def __dppl_take
+ * @brief The __dppl_take attribute indicates that the function "takes" over the
+ * ownership of the object and the user must not use the object as an argument
+ * to another function.
+ *
+ * The __dppl_take attribute mens that the function destroys it before the
+ * function returns, and the caller must not use the object again in any other
+ * function. If the pointer annotated with __dppl_take is NULL then it is
+ * treated as an error, since it may prevent the normal behavior of the
+ * function.
+ *
+ */
+#ifndef __dppl_take
+#define __dppl_take
+#endif
+/*!
+ * @def __dppl_keep
+ * @brief The __dppl_keep attribute indicates that the function only uses the
+ * object and does not destroy it before returning.
+ *
+ */
+#ifndef __dppl_keep
+#define __dppl_keep
+#endif
+/*!
+ * @def __dppl_null
+ * @brief The __dppl_null attribute indicates that a NULL value is returned.
+ *
+ */
+#ifndef __dppl_null
+#define __dppl_null
+#endif
+
+/** @} */

backends/include/dppl_data_types.h

@@ -0,0 +1,92 @@
+//===---------- dppl_data_types.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 file was copied over from the LLVM-C (include/llvm-c/DataTypes.h).
+/// This file contains definitions to figure out the size of _HOST_ data types.
+/// This file is important because different host OS's define different macros,
+/// which makes portability tough.  This file exports the following
+/// definitions:
+///
+/// [u]int(32|64)_t : typedefs for signed and unsigned 32/64 bit system types
+/// [U]INT(8|16|32|64)_(MIN|MAX) : Constants for the min and max values.
+///
+/// No library is required when using these functions.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#ifndef _MSC_VER
+
+#if !defined(UINT32_MAX)
+# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
+        "__STDC_LIMIT_MACROS before #including llvm-c/DataTypes.h"
+#endif
+
+#if !defined(UINT32_C)
+# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
+        "__STDC_CONSTANT_MACROS before #including llvm-c/DataTypes.h"
+#endif
+
+/* Note that <inttypes.h> includes <stdint.h>, if this is a C99 system. */
+#include <sys/types.h>
+
+#ifdef _AIX
+// GCC is strict about defining large constants: they must have LL modifier.
+#undef INT64_MAX
+#undef INT64_MIN
+#endif
+
+#else /* _MSC_VER */
+#ifdef __cplusplus
+#include <cstddef>
+#include <cstdlib>
+#else
+#include <stddef.h>
+#include <stdlib.h>
+#endif
+#include <sys/types.h>
+
+#if defined(_WIN64)
+typedef signed __int64 ssize_t;
+#else
+typedef signed int ssize_t;
+#endif /* _WIN64 */
+
+#endif /* _MSC_VER */
+
+/* Set defaults for constants which we cannot find. */
+#if !defined(INT64_MAX)
+# define INT64_MAX 9223372036854775807LL
+#endif
+#if !defined(INT64_MIN)
+# define INT64_MIN ((-INT64_MAX)-1)
+#endif
+#if !defined(UINT64_MAX)
+# define UINT64_MAX 0xffffffffffffffffULL
+#endif
+
+#ifndef HUGE_VALF
+#define HUGE_VALF (float)HUGE_VAL
+#endif