WIP: [SYCL][PI] Make PI an independent library

sycl/CMakeLists.txt

@@ -121,15 +121,43 @@ else()
   )
 endif()
 
+if(MSVC)
+  set(shared_library_dirname "bin")
+else()
+  set(shared_library_dirname "lib${LLVM_LIBDIR_SUFFIX}")
+endif()
+
+# Retrieves the name of the library
+# For example:
+#   get_library_path(libname "OpenCL" "external" SHARED)
+# would likely produce (depending on the system):
+#   set(libname "external/libOpenCL.so")
+function(get_library_path out name directory library_type)
+  set(library_prefix "${CMAKE_${library_type}_LIBRARY_PREFIX}")
+  set(library_suffix "${CMAKE_${library_type}_LIBRARY_SUFFIX}")
+  if(NOT ("${directory}" STREQUAL ""))
+    set(directory "${directory}/")
+  endif()
+  set(${out}
+      "${directory}${library_prefix}${name}${library_suffix}" PARENT_SCOPE)
+endfunction()
+
+# Retrieves the name of the library needed when linking
+# See get_library_path
+function(get_link_library_path out name directory)
+  if(MSVC)
+    get_library_path(tmp_out "${name}" "${directory}" STATIC)
+  else()
+    get_library_path(tmp_out "${name}" "${directory}" SHARED)
+  endif()
+  set(${out} "${tmp_out}" PARENT_SCOPE)
+endfunction()
+
 if( NOT OpenCL_LIBRARIES )
   message(STATUS "OpenCL_LIBRARIES is missing. Will try to download OpenCL ICD Loader from github.com")
+  get_link_library_path(OpenCL_LIBRARIES "OpenCL" "${LLVM_LIBRARY_OUTPUT_INTDIR}")
   if(MSVC)
-    set(OpenCL_LIBRARIES
-        "${LLVM_LIBRARY_OUTPUT_INTDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}OpenCL${CMAKE_STATIC_LIBRARY_SUFFIX}")
     list(APPEND AUX_CMAKE_FLAGS -DOPENCL_ICD_LOADER_REQUIRE_WDK=OFF)
-  else()
-    set(OpenCL_LIBRARIES
-        "${LLVM_LIBRARY_OUTPUT_INTDIR}/${CMAKE_SHARED_LIBRARY_PREFIX}OpenCL${CMAKE_SHARED_LIBRARY_SUFFIX}")
   endif()
   if (CMAKE_C_COMPILER)
       list(APPEND AUX_CMAKE_FLAGS -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER})
@@ -260,6 +288,9 @@ if (LLVM_ENABLE_ASSERTIONS AND NOT SYCL_DISABLE_STL_ASSERTIONS)
   endif()
 endif()
 
+include(piapi.cmake)
+add_piapi_library()
+
 set(SYCL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 # SYCL runtime library
@@ -311,9 +342,6 @@ option(SYCL_INCLUDE_TESTS
   "Generate build targets for the SYCL unit tests."
   ${LLVM_INCLUDE_TESTS})
 
-# Plugin Library
-add_subdirectory( plugins )
-
 add_subdirectory(tools)
 
 if(SYCL_INCLUDE_TESTS)
@@ -362,6 +390,11 @@ if(SYCL_BUILD_PI_CUDA)
         "CUDA support requires adding \"libclc\" to the CMake argument \"LLVM_ENABLE_PROJECTS\"")
   endif()
 
+  find_package(CUDA 10.1 REQUIRED)
+
+  set_target_properties(pi_cuda PROPERTIES
+    INTERFACE_LINK_LIBRARIES cudadrv
+  )
   add_dependencies(sycl-toolchain libspirv-builtins pi_cuda)
   list(APPEND SYCL_TOOLCHAIN_DEPLOY_COMPONENTS libspirv-builtins pi_cuda)
 endif()

sycl/cmake/modules/AddSYCLExecutable.cmake

@@ -2,7 +2,7 @@ macro(add_sycl_executable ARG_TARGET_NAME)
   cmake_parse_arguments(ARG
     ""
     ""
-    "OPTIONS;SOURCES;LIBRARIES;DEPENDANTS"
+    "OPTIONS;SOURCES;LIBRARIES;STATIC_LIBS;DEPENDANTS"
     ${ARGN})
 
   set(CXX_COMPILER clang++)
@@ -11,13 +11,24 @@ macro(add_sycl_executable ARG_TARGET_NAME)
       set(LIB_POSTFIX ".lib")
   else()
       set(LIB_PREFIX "-l")
+      set(SPLIT_LINK_PATH ON)
   endif()
   set(DEVICE_COMPILER_EXECUTABLE ${LLVM_RUNTIME_OUTPUT_INTDIR}/${CXX_COMPILER})
 
   # TODO add support for target_link_libraries(... PUBLIC ...)
   foreach(_lib ${ARG_LIBRARIES})
     list(APPEND LINKED_LIBS "${LIB_PREFIX}${_lib}${LIB_POSTFIX}")
   endforeach()
+  foreach(_lib ${ARG_STATIC_LIBS})
+    if(SPLIT_LINK_PATH)
+      # Note this has to be added separately so that CMake doesn't get confused
+      # by the space in between the two arguments
+      list(APPEND LINKED_LIBS "-L$<TARGET_FILE_DIR:${_lib}>")
+      list(APPEND LINKED_LIBS "-l:$<TARGET_FILE_NAME:${_lib}>")
+    else()
+      list(APPEND LINKED_LIBS $<TARGET_FILE:${_lib}>)
+    endif()
+  endforeach()
 
   if (LLVM_ENABLE_ASSERTIONS AND NOT SYCL_DISABLE_STL_ASSERTIONS)
     if(SYCL_USE_LIBCXX)

sycl/cmake/modules/AddSYCLUnitTest.cmake

@@ -90,12 +90,19 @@ macro(add_sycl_unittest_with_device test_dirname link_variant)
   endif()
 
   if ("${link_variant}" MATCHES "OBJECT")
+    # TODO piapi integration should be fixed,
+    # replace it with target_link_libraries(${test_dirname} PRIVATE piapi::piapi)
+    # once add_sycl_executable supports that
+    set(pi_include_dir "${sycl_inc_dir}/../piapi/include")
     add_sycl_executable(${test_dirname}
-      OPTIONS -nolibsycl ${COMMON_OPTS} ${LLVM_PTHREAD_LIB} ${TERMINFO_LIB}
+      OPTIONS -nolibsycl ${COMMON_OPTS} ${LLVM_PTHREAD_LIB} ${TERMINFO_LIB} ${piapi_options} -I "${pi_include_dir}" -DPI_DPCPP_INTEGRATION
       SOURCES ${ARGN} $<TARGET_OBJECTS:${sycl_obj_target}>
       LIBRARIES gtest_main gtest LLVMSupport LLVMTestingSupport OpenCL ${EXTRA_LIBS}
+      STATIC_LIBS piapi
       DEPENDANTS SYCLUnitTests)
+    add_dependencies(${test_dirname}_exec piapi)
   else()
     # TODO support shared library case.
   endif()
+  #target_link_libraries(${test_dirname}_exec PRIVATE piapi::piapi)
 endmacro()

sycl/doc/PluginInterface.md

@@ -72,8 +72,8 @@ SYCL_PI_TRACE=-1 lists all PI Traces above and more debug messages.
 
 #### Plugin binary interface
 Plugins should implement all the Interface APIs required for the PI Version
-it supports. There is [pi.def](../include/CL/sycl/detail/pi.def)/
-[pi.h](../include/CL/sycl/detail/pi.h) file listing all PI API names that can be
+it supports. There is [pi.def](../piapi/include/pi/pi.def)/
+[pi.h](../piapi/include/pi/pi.h) file listing all PI API names that can be
 called by the specific version of Plugin Interface.
 It exports a function - "piPluginInit" that returns the plugin details and
 function pointer table containing the list of pointers to implemented Interface
@@ -136,7 +136,7 @@ into
 - **Interoperability API** which allows interoperability with underlying
 runtimes such as OpenCL.
 
-See [pi.h](../include/CL/sycl/detail/pi.h) header for the full list and
+See [pi.h](../piapi/include/pi/pi.h) header for the full list and
 descriptions of PI APIs.
 
 ### The Core OpenCL-based PI APIs

sycl/include/CL/sycl/backend/cuda.hpp

@@ -13,6 +13,7 @@
 #include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/detail/pi_sycl.hpp>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/event.hpp>
 #include <CL/sycl/queue.hpp>
@@ -58,4 +59,4 @@ struct interop<backend::cuda, accessor<DataT, Dimensions, AccessMode,
 };
 
 } // namespace sycl
-} // namespace cl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/backend_types.hpp

@@ -9,19 +9,14 @@
 #pragma once
 
 #include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/detail/pi_sycl.hpp>
 
 #include <fstream>
 #include <iostream>
 #include <istream>
 #include <string>
 
-__SYCL_INLINE_NAMESPACE(cl) {
-namespace sycl {
-
-enum class backend : char { host, opencl, level_zero, cuda, all };
-
-template <backend name, typename SYCLObjectT> struct interop;
-
+namespace pi {
 inline std::ostream &operator<<(std::ostream &Out, backend be) {
   switch (be) {
   case backend::host:
@@ -41,6 +36,18 @@ inline std::ostream &operator<<(std::ostream &Out, backend be) {
   }
   return Out;
 }
+} // namespace pi
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+using backend = pi::backend;
+
+template <backend name, typename SYCLObjectT> struct interop;
+
+inline std::ostream &operator<<(std::ostream &Out, backend be) {
+  return pi::operator<<(Out, be);
+}
 
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/detail/common.hpp

@@ -20,18 +20,26 @@
 #define __SYCL_STRINGIFY_LINE_HELP(s) #s
 #define __SYCL_STRINGIFY_LINE(s) __SYCL_STRINGIFY_LINE_HELP(s)
 
+#ifdef XPTI_ENABLE_INSTRUMENTATION
+namespace pi {
+// We define a sycl stream name and this will be used by the instrumentation
+// framework
+extern const char *SYCL_STREAM_NAME;
+} // namespace pi
+#endif // XPTI_ENABLE_INSTRUMENTATION
+
 // Default signature enables the passing of user code location information to
 // public methods as a default argument. If the end-user wants to disable the
 // code location information, they must compile the code with
 // -DDISABLE_SYCL_INSTRUMENTATION_METADATA flag
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
-// We define a sycl stream name and this will be used by the instrumentation
-// framework
-constexpr const char *SYCL_STREAM_NAME = "sycl";
-// Stream name being used for traces generated from the SYCL plugin layer
-constexpr const char *SYCL_PICALL_STREAM_NAME = "sycl.pi";
+
+#ifdef XPTI_ENABLE_INSTRUMENTATION
+using pi::SYCL_STREAM_NAME;
+#endif // XPTI_ENABLE_INSTRUMENTATION
+
 // Data structure that captures the user code location information using the
 // builtin capabilities of the compiler
 struct code_location {

sycl/include/CL/sycl/detail/device_binary_image.hpp

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <CL/sycl/detail/os_util.hpp>
-#include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/detail/pi_sycl.hpp>
 
 #include <memory>
 

sycl/include/CL/sycl/detail/device_filter.hpp

@@ -11,44 +11,16 @@
 #include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/detail/defines.hpp>
 #include <CL/sycl/info/info_desc.hpp>
+#include <pi/device_filter.hpp>
 
 #include <iostream>
 #include <string>
 
-__SYCL_INLINE_NAMESPACE(cl) {
-namespace sycl {
-namespace detail {
-
-struct device_filter {
-  backend Backend = backend::all;
-  info::device_type DeviceType = info::device_type::all;
-  int DeviceNum = 0;
-  bool HasBackend = false;
-  bool HasDeviceType = false;
-  bool HasDeviceNum = false;
-  int MatchesSeen = 0;
-
-  device_filter(){};
-  device_filter(const std::string &FilterString);
-  friend std::ostream &operator<<(std::ostream &Out,
-                                  const device_filter &Filter);
-};
-
-class device_filter_list {
-  std::vector<device_filter> FilterList;
-
-public:
-  device_filter_list() {}
-  device_filter_list(const std::string &FilterString);
-  device_filter_list(device_filter &Filter);
-  void addFilter(device_filter &Filter);
-  std::vector<device_filter> &get() { return FilterList; }
-  friend std::ostream &operator<<(std::ostream &Out,
-                                  const device_filter_list &List);
-};
+namespace pi {
 
 inline std::ostream &operator<<(std::ostream &Out,
                                 const device_filter &Filter) {
+  namespace info = cl::sycl::info;
   Out << Filter.Backend << ":";
   if (Filter.DeviceType == info::device_type::host) {
     Out << "host";
@@ -78,6 +50,15 @@ inline std::ostream &operator<<(std::ostream &Out,
   return Out;
 }
 
+} // namespace pi
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+
+using pi::device_filter;
+using pi::device_filter_list;
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/detail/helpers.hpp

@@ -13,7 +13,7 @@
 #include <CL/sycl/access/access.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
-#include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/detail/pi_sycl.hpp>
 #include <CL/sycl/detail/type_traits.hpp>
 
 #if __cpp_lib_bit_cast

sycl/include/CL/sycl/detail/pi_sycl.hpp

@@ -0,0 +1,29 @@
+//==---------------- pi_sycl.hpp - SYCL wrapper for PI ---------*- C++ -*---==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// ===--------------------------------------------------------------------=== //
+
+#pragma once
+
+#include <CL/sycl/detail/defines.hpp>
+#include <pi/pi.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+namespace RT = ::pi;
+
+namespace detail {
+
+namespace RT = ::pi;
+using PiApiKind = ::PiApiKind;
+namespace pi {
+using namespace ::pi;
+}
+
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/detail/sycl_mem_obj_i.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/detail/pi_sycl.hpp>
 #include <CL/sycl/stl.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {

sycl/include/CL/sycl/detail/sycl_mem_obj_t.hpp

@@ -22,14 +22,17 @@
 #include <cstring>
 #include <type_traits>
 
+namespace pi {
+class plugin;
+}
+
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 namespace detail {
 
 // Forward declarations
 class context_impl;
 class event_impl;
-class plugin;
 
 using ContextImplPtr = shared_ptr_class<context_impl>;
 using EventImplPtr = shared_ptr_class<event_impl>;
@@ -86,7 +89,7 @@ class __SYCL_EXPORT SYCLMemObjT : public SYCLMemObjI {
 
   virtual ~SYCLMemObjT() = default;
 
-  const plugin &getPlugin() const;
+  const pi::plugin &getPlugin() const;
 
   __SYCL_DLL_LOCAL size_t getSize() const override { return MSizeInBytes; }
   __SYCL_DLL_LOCAL size_t get_count() const {