Merge branch 'sycl' into sean/async-alloc-maxSize-ifdef

Author: Seanst98

llvm/cmake/modules/AddSecurityFlags.cmake

@@ -31,7 +31,7 @@ macro(add_link_option_ext flag name)
   endif()
 endmacro()
 
-function(append_common_extra_security_flags)
+macro(append_common_extra_security_flags)
   if( LLVM_ON_UNIX )
     # Fortify Source (strongly recommended):
     if (CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -70,7 +70,7 @@ function(append_common_extra_security_flags)
       CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS
       CMAKE_SHARED_LINKER_FLAGS)
   endif()
-endfunction()
+endmacro()
 
 if ( EXTRA_SECURITY_FLAGS )
     if (EXTRA_SECURITY_FLAGS STREQUAL "none")

sycl/include/sycl/handler.hpp

@@ -213,6 +213,7 @@ class HandlerAccess;
 class HostTask;
 
 using EventImplPtr = std::shared_ptr<event_impl>;
+using DeviceImplPtr = std::shared_ptr<device_impl>;
 
 template <typename RetType, typename Func, typename Arg>
 static Arg member_ptr_helper(RetType (Func::*)(Arg) const);
@@ -249,6 +250,7 @@ template <typename Type> struct get_kernel_wrapper_name_t {
 };
 
 __SYCL_EXPORT device getDeviceFromHandler(handler &);
+const DeviceImplPtr &getDeviceImplFromHandler(handler &);
 
 // Checks if a device_global has any registered kernel usage.
 __SYCL_EXPORT bool isDeviceGlobalUsedInKernel(const void *DeviceGlobalPtr);
@@ -3481,6 +3483,8 @@ class __SYCL_EXPORT handler {
             typename PropertyListT>
   friend class accessor;
   friend device detail::getDeviceFromHandler(handler &);
+  friend const detail::DeviceImplPtr &
+  detail::getDeviceImplFromHandler(handler &);
 
   template <typename DataT, int Dimensions, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>

sycl/source/detail/cg.hpp

@@ -686,7 +686,7 @@ class CGAsyncAlloc : public CG {
       ur_event_handle_t event, CG::StorageInitHelper CGData,
       detail::code_location loc = {})
       : CG(CGType::AsyncAlloc, std::move(CGData), std::move(loc)), MSize(size),
-        MMemPool(MemPool), MEvent(event) {}
+        MMemPool(std::move(MemPool)), MEvent(event) {}
 
   std::shared_ptr<ext::oneapi::experimental::detail::memory_pool_impl>
   getMemPool() const {

sycl/source/detail/context_impl.cpp

@@ -567,7 +567,7 @@ void context_impl::verifyProps(const property_list &Props) const {
 std::shared_ptr<sycl::ext::oneapi::experimental::detail::memory_pool_impl>
 context_impl::get_default_memory_pool(const context &Context,
                                       const device &Device,
-                                      const usm::alloc &Kind) {
+                                      [[maybe_unused]] const usm::alloc &Kind) {
 
   assert(Kind == usm::alloc::device);
 

sycl/source/detail/graph_impl.hpp

@@ -919,6 +919,12 @@ class graph_impl : public std::enable_shared_from_this<graph_impl> {
   /// @return Context associated with graph.
   sycl::context getContext() const { return MContext; }
 
+  /// Query for the device_impl tied to this graph.
+  /// @return device_impl shared ptr reference associated with graph.
+  const DeviceImplPtr &getDeviceImplPtr() const {
+    return getSyclObjImpl(MDevice);
+  }
+
   /// Query for the device tied to this graph.
   /// @return Device associated with graph.
   sycl::device getDevice() const { return MDevice; }

sycl/source/detail/handler_impl.hpp

@@ -207,8 +207,8 @@ class handler_impl {
   /// potential logging.
   /// Event computed from async alloc which is passed through for processing.
   std::shared_ptr<ext::oneapi::experimental::detail::memory_pool_impl> MMemPool;
-  size_t MAllocSize;
-  ur_event_handle_t MAsyncAllocEvent;
+  size_t MAllocSize = 0;
+  ur_event_handle_t MAsyncAllocEvent = nullptr;
 
   // Allocation ptr to be freed asynchronously.
   void *MFreePtr = nullptr;

sycl/source/detail/memory_pool_impl.cpp

@@ -123,10 +123,14 @@ memory_pool_impl::~memory_pool_impl() {
   if (MIsDefaultPool)
     return;
 
-  ur_usm_pool_handle_t handle = this->get_handle();
-  sycl::context ctx = this->get_context();
-  sycl::device dev = this->get_device();
-  destroy_memory_pool(ctx, dev, handle);
+  try {
+    ur_usm_pool_handle_t handle = this->get_handle();
+    sycl::context ctx = this->get_context();
+    sycl::device dev = this->get_device();
+    destroy_memory_pool(ctx, dev, handle);
+  } catch (std::exception &e) {
+    __SYCL_REPORT_EXCEPTION_TO_STREAM("exception in ~memory_pool_impl", e);
+  }
 }
 
 size_t memory_pool_impl::get_threshold() const {

sycl/source/detail/scheduler/commands.cpp

@@ -3750,6 +3750,7 @@ ur_result_t ExecCGCommand::enqueueImpQueue() {
     return UR_RESULT_SUCCESS;
   }
   case CGType::AsyncFree: {
+    assert(MQueue && "Async free submissions should have an associated queue");
     CGAsyncFree *AsyncFree = (CGAsyncFree *)MCommandGroup.get();
     const detail::AdapterPtr &Adapter = MQueue->getAdapter();
     void *ptr = AsyncFree->getPtr();

sycl/source/handler.cpp

@@ -43,6 +43,15 @@ inline namespace _V1 {
 
 namespace detail {
 
+const DeviceImplPtr &getDeviceImplFromHandler(handler &CGH) {
+  assert((CGH.MQueue || getSyclObjImpl(CGH)->MGraph) &&
+         "One of MQueue or MGraph should be nonnull!");
+  if (CGH.MQueue)
+    return CGH.MQueue->getDeviceImplPtr();
+
+  return getSyclObjImpl(CGH)->MGraph->getDeviceImplPtr();
+}
+
 bool isDeviceGlobalUsedInKernel(const void *DeviceGlobalPtr) {
   DeviceGlobalMapEntry *DGEntry =
       detail::ProgramManager::getInstance().getDeviceGlobalEntry(
@@ -2059,10 +2068,10 @@ void handler::setUserFacingNodeType(ext::oneapi::experimental::node_type Type) {
 }
 
 std::optional<std::array<size_t, 3>> handler::getMaxWorkGroups() {
-  auto Dev = detail::getSyclObjImpl(detail::getDeviceFromHandler(*this));
+  const auto &DeviceImpl = detail::getDeviceImplFromHandler(*this);
   std::array<size_t, 3> UrResult = {};
-  auto Ret = Dev->getAdapter()->call_nocheck<UrApiKind::urDeviceGetInfo>(
-      Dev->getHandleRef(),
+  auto Ret = DeviceImpl->getAdapter()->call_nocheck<UrApiKind::urDeviceGetInfo>(
+      DeviceImpl->getHandleRef(),
       UrInfoCode<
           ext::oneapi::experimental::info::device::max_work_groups<3>>::value,
       sizeof(UrResult), &UrResult, nullptr);