Support filter selector

.gitignore

@@ -83,3 +83,6 @@ target/
 
 # generated Cython files
 _dpctl_bindings*
+
+# generated C API coverage reports
+dpctl-c-api-coverage

dpctl-capi/CMakeLists.txt

@@ -64,6 +64,13 @@ endif()
 file(GLOB_RECURSE sources
     ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
 )
+
+# Exclude from sources
+list(REMOVE_ITEM
+    sources
+    "${CMAKE_CURRENT_SOURCE_DIR}/source/dpctl_vector_templ.cpp"
+)
+
 file(GLOB_RECURSE helper_sources
     ${CMAKE_CURRENT_SOURCE_DIR}/helper/source/*.cpp
 )

dpctl-capi/helper/include/dpctl_async_error_handler.h

@@ -0,0 +1,42 @@
+//===-- dpctl_async_error_handler.h - An async error handler     -*-C++-*- ===//
+//
+//                      Data Parallel Control (dpCtl)
+//
+// Copyright 2020-2021 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
+/// A functor to use for passing an error handler callback function to sycl
+/// context and queue contructors.
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "dpctl_error_handler_type.h"
+#include <CL/sycl.hpp>
+
+class DPCTL_AsycErrorHandler
+{
+    error_handler_callback *handler_ = nullptr;
+
+public:
+    DPCTL_AsycErrorHandler(error_handler_callback *err_handler)
+        : handler_(err_handler)
+    {
+    }
+
+    void operator()(const cl::sycl::exception_list &exceptions);
+};

dpctl-capi/helper/include/dpctl_utils_helper.h

@@ -24,8 +24,74 @@
 
 #pragma once
 
+#include "../include/dpctl_sycl_enum_types.h"
 #include <CL/sycl.hpp>
-using namespace cl::sycl;
 
-std::string DPCTL_DeviceTypeToStr(info::device_type devTy);
-info::device_type DPCTL_StrToDeviceType(std::string devTyStr);
+/*!
+ * @brief Converts a sycl::info::device_type input value to a string.
+ *
+ * @param    devTy          A sycl::info::device_type enum value.
+ * @return   A string representation of a sycl::info::device_type enum.
+ */
+std::string DPCTL_DeviceTypeToStr(sycl::info::device_type devTy);
+
+/*!
+ * @brief Converts a string to sycl::info::device_type enum value.
+ *
+ * Tries to interpret the input string a return a corresponding device_type. If
+ * no conversion is possible, then a runtime_error is thrown.
+ *
+ * @param    devTyStr       Input string for which we search a
+ *                          sycl::info::device_type enum value.
+ * @return   The sycl::info::device_type enum value corresponding to the input
+ * string.
+ * @throws runtime_error
+ */
+sycl::info::device_type DPCTL_StrToDeviceType(const std::string &devTyStr);
+
+/*!
+ * @brief Converts a DPCTLSyclBackendType enum value to its corresponding
+ * sycl::backend enum value. If conversion fails, a runtime_error is thrown.
+ *
+ * @param    BeTy           My Param doc
+ * @return   A sycl::backend enum value for the input
+ * DPCTLSyclDeviceType enum value.
+ * @throws runtime_error
+ */
+sycl::backend DPCTL_DPCTLBackendTypeToSyclBackend(DPCTLSyclBackendType BeTy);
+
+/*!
+ * @brief Converts a sycl::backend enum value to corresponding
+ * DPCTLSyclBackendType enum value.
+ *
+ * @param    B           sycl::backend to be converted to
+ *                       DPCTLSyclBackendType enum.
+ * @return   A DPCTLSyclBackendType enum value for the input
+ * sycl::backend enum value.
+ */
+DPCTLSyclBackendType DPCTL_SyclBackendToDPCTLBackendType(sycl::backend B);
+
+/*!
+ * @brief Converts a DPCTLSyclDeviceType enum value to its corresponding
+ * sycl::info::device_type enum value. If conversion fails, a runtime_error is
+ * thrown.
+ *
+ * @param    DTy           A DPCTLSyclDeviceType enum value
+ * @return   A sycl::info::device_type enum value for the input
+ * DPCTLSyclDeviceType enum value.
+ * @throws runtime_error
+ */
+sycl::info::device_type
+DPCTL_DPCTLDeviceTypeToSyclDeviceType(DPCTLSyclDeviceType DTy);
+
+/*!
+ * @brief Converts a sycl::info::device_type enum value to corresponding
+ * DPCTLSyclDeviceType enum value.
+ *
+ * @param    D           sycl::info::device_type to be converted to
+ *                       DPCTLSyclDeviceType enum.
+ * @return   A DPCTLSyclDeviceType enum value for the input
+ * sycl::info::device_type enum value.
+ */
+DPCTLSyclDeviceType
+DPCTL_SyclDeviceTypeToDPCTLDeviceType(sycl::info::device_type D);

dpctl-capi/helper/include/dpctl_vector_macros.h

@@ -0,0 +1,33 @@
+//=== dpctl_vector_macros.h - Macros to help build function sig.    -*-C++-*- //
+//
+//                      Data Parallel Control (dpCtl)
+//
+// Copyright 2020-2021 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 These macros are used in dpctl_vector_templ.cpp. They help build the
+/// function signatures for the functions defined in dpctl_vector_templ.cpp.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#define xFN(TYPE, NAME) DPCTL##TYPE##Vector##_##NAME
+#define FN(TYPE, NAME) xFN(TYPE, NAME)
+#define xVECTOR(EL) DPCTL##EL##VectorRef
+#define VECTOR(EL) xVECTOR(EL)
+#define xSYCLREF(EL) DPCTLSycl##EL##Ref
+#define SYCLREF(EL) xSYCLREF(EL)

dpctl-capi/helper/source/dpctl_async_error_handler.cpp

@@ -0,0 +1,42 @@
+//===-- dpctl_async_error_handler.h - An async error handler     -*-C++-*- ===//
+//
+//                      Data Parallel Control (dpCtl)
+//
+// Copyright 2020-2021 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
+/// A functor to use for passing an error handler callback function to sycl
+/// context and queue contructors.
+//===----------------------------------------------------------------------===//
+
+#include "dpctl_async_error_handler.h"
+
+void DPCTL_AsycErrorHandler::operator()(
+    const cl::sycl::exception_list &exceptions)
+{
+    for (std::exception_ptr const &e : exceptions) {
+        try {
+            std::rethrow_exception(e);
+        } catch (cl::sycl::exception const &e) {
+            std::cerr << "Caught asynchronous SYCL exception:\n"
+                      << e.what() << std::endl;
+            // FIXME: Change get_cl_code() to code() once DPCPP supports it.
+            auto err_code = e.get_cl_code();
+            handler_(err_code);
+        }
+    }
+}

dpctl-capi/helper/source/dpctl_utils_helper.cpp

@@ -60,7 +60,7 @@ std::string DPCTL_DeviceTypeToStr(info::device_type devTy)
 /*!
  * Transforms string to enum info::device_type.
  */
-info::device_type DPCTL_StrToDeviceType(std::string devTyStr)
+info::device_type DPCTL_StrToDeviceType(const std::string &devTyStr)
 {
     info::device_type devTy;
     if (devTyStr == "cpu") {
@@ -84,3 +84,79 @@ info::device_type DPCTL_StrToDeviceType(std::string devTyStr)
     }
     return devTy;
 }
+
+backend DPCTL_DPCTLBackendTypeToSyclBackend(DPCTLSyclBackendType BeTy)
+{
+    switch (BeTy) {
+    case DPCTLSyclBackendType::DPCTL_CUDA:
+        return backend::cuda;
+    case DPCTLSyclBackendType::DPCTL_HOST:
+        return backend::host;
+    case DPCTLSyclBackendType::DPCTL_LEVEL_ZERO:
+        return backend::level_zero;
+    case DPCTLSyclBackendType::DPCTL_OPENCL:
+        return backend::opencl;
+    default:
+        throw runtime_error("Unsupported backend type", -1);
+    }
+}
+
+DPCTLSyclBackendType DPCTL_SyclBackendToDPCTLBackendType(backend B)
+{
+    switch (B) {
+    case backend::cuda:
+        return DPCTLSyclBackendType::DPCTL_CUDA;
+    case backend::host:
+        return DPCTLSyclBackendType::DPCTL_HOST;
+    case backend::level_zero:
+        return DPCTLSyclBackendType::DPCTL_LEVEL_ZERO;
+    case backend::opencl:
+        return DPCTLSyclBackendType::DPCTL_OPENCL;
+    default:
+        return DPCTLSyclBackendType::DPCTL_UNKNOWN_BACKEND;
+    }
+}
+
+info::device_type DPCTL_DPCTLDeviceTypeToSyclDeviceType(DPCTLSyclDeviceType DTy)
+{
+    switch (DTy) {
+    case DPCTLSyclDeviceType::DPCTL_ACCELERATOR:
+        return info::device_type::accelerator;
+    case DPCTLSyclDeviceType::DPCTL_ALL:
+        return info::device_type::all;
+    case DPCTLSyclDeviceType::DPCTL_AUTOMATIC:
+        return info::device_type::automatic;
+    case DPCTLSyclDeviceType::DPCTL_CPU:
+        return info::device_type::cpu;
+    case DPCTLSyclDeviceType::DPCTL_CUSTOM:
+        return info::device_type::custom;
+    case DPCTLSyclDeviceType::DPCTL_GPU:
+        return info::device_type::gpu;
+    case DPCTLSyclDeviceType::DPCTL_HOST_DEVICE:
+        return info::device_type::host;
+    default:
+        throw runtime_error("Unsupported device type", -1);
+    }
+}
+
+DPCTLSyclDeviceType DPCTL_SyclDeviceTypeToDPCTLDeviceType(info::device_type D)
+{
+    switch (D) {
+    case info::device_type::accelerator:
+        return DPCTLSyclDeviceType::DPCTL_ACCELERATOR;
+    case info::device_type::all:
+        return DPCTLSyclDeviceType::DPCTL_ALL;
+    case info::device_type::automatic:
+        return DPCTLSyclDeviceType::DPCTL_AUTOMATIC;
+    case info::device_type::cpu:
+        return DPCTLSyclDeviceType::DPCTL_CPU;
+    case info::device_type::custom:
+        return DPCTLSyclDeviceType::DPCTL_CUSTOM;
+    case info::device_type::gpu:
+        return DPCTLSyclDeviceType::DPCTL_GPU;
+    case info::device_type::host:
+        return DPCTLSyclDeviceType::DPCTL_HOST_DEVICE;
+    default:
+        return DPCTLSyclDeviceType::DPCTL_UNKNOWN_DEVICE;
+    }
+}

dpctl-capi/include/dpctl_error_handler_type.h

@@ -0,0 +1,34 @@
+//===--- dpctl_error_handler_types.h - Error handler callbacks   -*-C++-*- ===//
+//
+//                      Data Parallel Control (dpCtl)
+//
+// Copyright 2020-2021 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 types for callback functions to use for error handling in dpctl.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+/*!
+ * @brief
+ *
+ * @param    err_code       My Param doc
+ * @return   {return}       My Param doc
+ */
+typedef void error_handler_callback(int err_code);

dpctl-capi/include/dpctl_sycl_context_interface.h

@@ -28,13 +28,42 @@
 #include "Support/DllExport.h"
 #include "Support/ExternC.h"
 #include "Support/MemOwnershipAttrs.h"
+#include "dpctl_async_error_handler.h"
 #include "dpctl_data_types.h"
-#include "dpctl_sycl_platform_interface.h"
+#include "dpctl_sycl_enum_types.h"
 #include "dpctl_sycl_types.h"
 #include <stdbool.h>
 
 DPCTL_C_EXTERN_C_BEGIN
 
+/*!
+ * @brief
+ *
+ * @param    DRef           My Param doc
+ * @param    error_handler  My Param doc
+ * @param    properties     My Param doc
+ * @return   {return}       My Param doc
+ */
+DPCTL_API
+__dpctl_give DPCTLSyclContextRef
+DPCTLContext_Create(__dpctl_keep const DPCTLSyclDeviceRef DRef,
+                    error_handler_callback *error_handler,
+                    int properties);
+
+/*!
+ * @brief
+ *
+ * @param    DVRef          My Param doc
+ * @param    error_handler  My Param doc
+ * @param    properties     My Param doc
+ * @return   {return}       My Param doc
+ */
+DPCTL_API
+__dpctl_give DPCTLSyclContextRef DPCTLContext_CreateFromDeviceVector(
+    __dpctl_keep const DPCTLDeviceVectorRef DVRef,
+    error_handler_callback *error_handler,
+    int properties);
+
 /*!
  * @brief Checks if two DPCTLSyclContextRef objects point to the same
  * sycl::context.