[SYCL] Move internal headers to source dir (#1136)

Move internal headers from include/CL/sycl to source directory to
prevent implementation details leak to user application and enforce
stable ABI.

A few more changes were applied to make the movement possible:

- addHostAccessorAndWait functions in accessor to avoid calls to RT
  internals from header file
- Removed getImageInfo
- Move buffer size acquisition from buffer constructor to SYCLMemObjT
  cpp to avoid calls to PI
- getPluginFromContext function in context
- Standard containers replaced with SYCL variants in sycl_mem_obj_i.hpp.
  Unique ptr replaced with shared
- A few implementations moved from queue.hpp to queue.cpp
- Some LIT tests temporarily include implementaion specific headers.
  They will be converted to unit tests later.

Signed-off-by: Alexander Batashev <[email protected]>

Author: Alexander Batashev

sycl/CMakeLists.txt

@@ -185,6 +185,8 @@ function( add_common_options LIB_NAME)
   endif()
 endfunction(add_common_options)
 
+set(SYCL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
 # SYCL runtime library
 add_subdirectory( source )
 

sycl/include/CL/sycl/accessor.hpp

@@ -16,7 +16,6 @@
 #include <CL/sycl/detail/generic_type_traits.hpp>
 #include <CL/sycl/detail/image_accessor_util.hpp>
 #include <CL/sycl/detail/image_ocl_types.hpp>
-#include <CL/sycl/detail/queue_impl.hpp>
 #include <CL/sycl/exception.hpp>
 #include <CL/sycl/handler.hpp>
 #include <CL/sycl/id.hpp>
@@ -167,6 +166,8 @@ static T<NewDim> convertToArrayOfN(T<OldDim> OldObj) {
   return NewObj;
 }
 
+device getDeviceFromHandler(handler &CommandGroupHandlerRef);
+
 template <typename DataT, int Dimensions, access::mode AccessMode,
           access::target AccessTarget, access::placeholder IsPlaceholder>
 class accessor_common {
@@ -397,10 +398,7 @@ class image_accessor
         MImageCount(ImageRef.get_count()),
         MImgChannelOrder(detail::getSyclObjImpl(ImageRef)->getChannelOrder()),
         MImgChannelType(detail::getSyclObjImpl(ImageRef)->getChannelType()) {
-    detail::EventImplPtr Event =
-        detail::Scheduler::getInstance().addHostAccessor(
-            AccessorBaseHost::impl.get());
-    Event->wait(Event);
+    addHostAccessorAndWait(AccessorBaseHost::impl.get());
   }
 #endif
 
@@ -429,7 +427,7 @@ class image_accessor
         MImgChannelOrder(detail::getSyclObjImpl(ImageRef)->getChannelOrder()),
         MImgChannelType(detail::getSyclObjImpl(ImageRef)->getChannelType()) {
     checkDeviceFeatureSupported<info::device::image_support>(
-        CommandGroupHandlerRef.MQueue->get_device());
+        getDeviceFromHandler(CommandGroupHandlerRef));
   }
 #endif
 
@@ -770,12 +768,8 @@ class accessor :
             detail::convertToArrayOfN<3, 1>(BufferRef.get_range()), AccessMode,
             detail::getSyclObjImpl(BufferRef).get(), AdjustedDim, sizeof(DataT),
             BufferRef.OffsetInBytes, BufferRef.IsSubBuffer) {
-    if (!IsPlaceH) {
-      detail::EventImplPtr Event =
-          detail::Scheduler::getInstance().addHostAccessor(
-              AccessorBaseHost::impl.get());
-      Event->wait(Event);
-    }
+    if (!IsPlaceH)
+      addHostAccessorAndWait(AccessorBaseHost::impl.get());
 #endif
   }
 
@@ -814,12 +808,8 @@ class accessor :
             detail::convertToArrayOfN<3, 1>(BufferRef.get_range()), AccessMode,
             detail::getSyclObjImpl(BufferRef).get(), Dimensions, sizeof(DataT),
             BufferRef.OffsetInBytes, BufferRef.IsSubBuffer) {
-    if (!IsPlaceH) {
-      detail::EventImplPtr Event =
-          detail::Scheduler::getInstance().addHostAccessor(
-              AccessorBaseHost::impl.get());
-      Event->wait(Event);
-    }
+    if (!IsPlaceH)
+      addHostAccessorAndWait(AccessorBaseHost::impl.get());
   }
 #endif
 
@@ -858,12 +848,8 @@ class accessor :
                          AccessMode, detail::getSyclObjImpl(BufferRef).get(),
                          Dimensions, sizeof(DataT), BufferRef.OffsetInBytes,
                          BufferRef.IsSubBuffer) {
-    if (!IsPlaceH) {
-      detail::EventImplPtr Event =
-          detail::Scheduler::getInstance().addHostAccessor(
-              AccessorBaseHost::impl.get());
-      Event->wait(Event);
-    }
+    if (!IsPlaceH)
+      addHostAccessorAndWait(AccessorBaseHost::impl.get());
   }
 #endif
 

sycl/include/CL/sycl/buffer.hpp

@@ -194,11 +194,8 @@ class buffer {
          event AvailableEvent = {})
       : Range{0} {
 
-    size_t BufSize = 0;
-    const detail::plugin &Plugin = detail::getSyclObjImpl(SyclContext)->getPlugin();
-    Plugin.call<detail::PiApiKind::piMemGetInfo>(
-        detail::pi::cast<detail::RT::PiMem>(MemObject), CL_MEM_SIZE,
-        sizeof(size_t), &BufSize, nullptr);
+    size_t BufSize = detail::SYCLMemObjT::getBufSizeForContext(
+        detail::getSyclObjImpl(SyclContext), MemObject);
 
     Range[0] = BufSize / sizeof(T);
     impl = std::make_shared<detail::buffer_impl>(

sycl/include/CL/sycl/detail/accessor_impl.hpp

@@ -185,6 +185,8 @@ class LocalAccessorBaseHost {
 
 using Requirement = AccessorImplHost;
 
+void addHostAccessorAndWait(Requirement *Req);
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/detail/image_impl.hpp

@@ -219,15 +219,6 @@ template <int Dimensions> class image_impl final : public SYCLMemObjT {
   ~image_impl() { BaseT::updateHostMemory(); }
 
 private:
-  template <typename T>
-  void getImageInfo(const ContextImplPtr Context, RT::PiMemImageInfo Info,
-                    T &Dest) {
-    const detail::plugin &Plugin = Context->getPlugin();
-    RT::PiMem Mem = pi::cast<RT::PiMem>(BaseT::MInteropMemObject);
-    Plugin.call<PiApiKind::piMemImageGetInfo>(Mem, Info, sizeof(T), &Dest,
-                                              nullptr);
-  }
-
   vector_class<device> getDevices(const ContextImplPtr Context);
 
   template <info::device Param>

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

@@ -9,7 +9,7 @@
 #pragma once
 
 #include <CL/sycl/detail/pi.hpp>
-#include <memory>
+#include <CL/sycl/stl.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
@@ -20,8 +20,8 @@ class event_impl;
 class context_impl;
 struct MemObjRecord;
 
-using EventImplPtr = std::shared_ptr<detail::event_impl>;
-using ContextImplPtr = std::shared_ptr<detail::context_impl>;
+using EventImplPtr = shared_ptr_class<detail::event_impl>;
+using ContextImplPtr = shared_ptr_class<detail::context_impl>;
 
 // The class serves as an interface in the scheduler for all SYCL memory
 // objects.
@@ -64,7 +64,10 @@ class SYCLMemObjI {
 protected:
   // Pointer to the record that contains the memory commands. This is managed
   // by the scheduler.
-  std::unique_ptr<MemObjRecord> MRecord;
+  // fixme replace with unique_ptr_class once it is implemented. Standard
+  // unique_ptr requires knowlege of sizeof(MemObjRecord) at compile time
+  // which is unavailable.
+  shared_ptr_class<MemObjRecord> MRecord;
   friend class Scheduler;
 };
 

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

@@ -9,9 +9,7 @@
 #pragma once
 
 #include <CL/sycl/detail/common.hpp>
-#include <CL/sycl/detail/context_impl.hpp>
 #include <CL/sycl/detail/sycl_mem_obj_allocator.hpp>
-#include <CL/sycl/detail/plugin.hpp>
 #include <CL/sycl/detail/sycl_mem_obj_i.hpp>
 #include <CL/sycl/detail/type_traits.hpp>
 #include <CL/sycl/event.hpp>
@@ -26,7 +24,9 @@ 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>;
@@ -83,11 +83,8 @@ class SYCLMemObjT : public SYCLMemObjI {
 
   virtual ~SYCLMemObjT() = default;
 
-  const plugin &getPlugin() const {
-    assert((MInteropContext != nullptr) &&
-           "Trying to get Plugin from SYCLMemObjT with nullptr ContextImpl.");
-    return (MInteropContext->getPlugin());
-  }
+  const plugin &getPlugin() const;
+
   size_t getSize() const override { return MSizeInBytes; }
   size_t get_count() const {
     size_t AllocatorValueSize = MAllocator->getValueSize();
@@ -259,6 +256,9 @@ class SYCLMemObjT : public SYCLMemObjI {
     MAllocator->setAlignment(RequiredAlign);
   }
 
+  static size_t getBufSizeForContext(const ContextImplPtr &Context,
+                                     cl_mem MemObject);
+
 protected:
   // Allocator used for allocation memory on host.
   unique_ptr_class<SYCLMemObjAllocator> MAllocator;

sycl/include/CL/sycl/handler.hpp

@@ -59,6 +59,7 @@ namespace sycl {
 
 // Forward declaration
 
+class handler;
 template <typename T, int Dimensions, typename AllocatorT> class buffer;
 namespace detail {
 
@@ -104,6 +105,7 @@ template <typename Type> struct get_kernel_name_t<detail::auto_name, Type> {
   using name = Type;
 };
 
+device getDeviceFromHandler(handler &);
 } // namespace detail
 
 /// 4.8.3 Command group handler class
@@ -1278,6 +1280,7 @@ class handler {
   template <typename DataT, int Dims, access::mode AccMode,
             access::target AccTarget, access::placeholder isPlaceholder>
   friend class accessor;
+  friend device detail::getDeviceFromHandler(handler &);
 
   template <typename DataT, int Dimensions, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>

sycl/include/CL/sycl/intel/function_pointer.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include <CL/sycl/detail/plugin.hpp>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/program.hpp>
 #include <CL/sycl/stl.hpp>

sycl/include/CL/sycl/platform.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 #include <CL/sycl/detail/common.hpp>
-#include <CL/sycl/detail/platform_info.hpp>
 #include <CL/sycl/stl.hpp>
 
 // 4.6.2 Platform class

sycl/include/CL/sycl/queue.hpp

@@ -9,9 +9,11 @@
 #pragma once
 
 #include <CL/sycl/detail/common.hpp>
+#include <CL/sycl/device.hpp>
 #include <CL/sycl/device_selector.hpp>
 #include <CL/sycl/event.hpp>
 #include <CL/sycl/exception_list.hpp>
+#include <CL/sycl/handler.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/property_list.hpp>
 #include <CL/sycl/stl.hpp>
@@ -107,10 +109,7 @@ class queue {
   /// @param SyclDevice is an instance of SYCL device.
   /// @param PropList is a list of properties for queue construction.
   queue(const context &SyclContext, const device &SyclDevice,
-        const property_list &PropList = {})
-      : queue(SyclContext, SyclDevice,
-              detail::getSyclObjImpl(SyclContext)->get_async_handler(),
-              PropList) {};
+        const property_list &PropList = {});
 
   /// Constructs a SYCL queue associated with the given context, device,
   /// asynchronous exception handler and optional properties list.
@@ -447,9 +446,7 @@ class queue {
   /// Returns whether the queue is in order or OoO
   ///
   /// Equivalent to has_property<property::queue::in_order>()
-  bool is_in_order() const {
-    return impl->has_property<property::queue::in_order>();
-  }
+  bool is_in_order() const;
 
 private:
   shared_ptr_class<detail::queue_impl> impl;

sycl/source/CMakeLists.txt

@@ -82,6 +82,7 @@ set(SYCL_SOURCES
     "detail/usm/usm_dispatch.cpp"
     "detail/usm/usm_impl.cpp"
     "detail/util.cpp"
+    "accessor.cpp"
     "context.cpp"
     "device.cpp"
     "device_selector.cpp"

sycl/source/accessor.cpp

@@ -0,0 +1,20 @@
+//==------------ accessor.cpp - SYCL standard source file ------------------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl/accessor.hpp>
+#include <detail/queue_impl.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace detail {
+device getDeviceFromHandler(handler &CommandGroupHandlerRef) {
+  return CommandGroupHandlerRef.MQueue->get_device();
+}
+} // namespace detail
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/context.cpp

@@ -8,13 +8,14 @@
 
 #include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/common.hpp>
-#include <CL/sycl/detail/context_impl.hpp>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/device_selector.hpp>
 #include <CL/sycl/exception.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/platform.hpp>
 #include <CL/sycl/stl.hpp>
+#include <detail/context_impl.hpp>
+
 #include <algorithm>
 #include <memory>
 #include <utility>

sycl/source/detail/accessor_impl.cpp

@@ -7,7 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include <CL/sycl/detail/accessor_impl.hpp>
-#include <CL/sycl/detail/scheduler/scheduler.hpp>
+#include <detail/event_impl.hpp>
+#include <detail/scheduler/scheduler.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
@@ -17,6 +18,12 @@ AccessorImplHost::~AccessorImplHost() {
   if (MBlockedCmd)
     detail::Scheduler::getInstance().releaseHostAccessor(this);
 }
+
+void addHostAccessorAndWait(Requirement *Req) {
+  detail::EventImplPtr Event =
+      detail::Scheduler::getInstance().addHostAccessor(Req);
+  Event->wait(Event);
+}
 }
 }
 }

sycl/source/detail/buffer_impl.cpp

@@ -7,9 +7,9 @@
 //===----------------------------------------------------------------------===//
 
 #include <CL/sycl/detail/buffer_impl.hpp>
-#include <CL/sycl/detail/context_impl.hpp>
 #include <CL/sycl/detail/memory_manager.hpp>
-#include <CL/sycl/detail/scheduler/scheduler.hpp>
+#include <detail/context_impl.hpp>
+#include <detail/scheduler/scheduler.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {

sycl/source/detail/config.hpp

@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include <CL/sycl/detail/defines.hpp>
+
 #include <cstdlib>
 
 __SYCL_INLINE_NAMESPACE(cl) {

sycl/source/detail/context_impl.cpp

@@ -8,14 +8,14 @@
 
 #include <CL/sycl/detail/clusm.hpp>
 #include <CL/sycl/detail/common.hpp>
-#include <CL/sycl/detail/context_impl.hpp>
-#include <CL/sycl/detail/context_info.hpp>
 #include <CL/sycl/device.hpp>
 #include <CL/sycl/exception.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/info/info_desc.hpp>
 #include <CL/sycl/platform.hpp>
 #include <CL/sycl/stl.hpp>
+#include <detail/context_impl.hpp>
+#include <detail/context_info.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {