[SYCL] Fix issues on Windows: aligned alloc, prefetch, __builtin_expect, /EHsc

Signed-off-by: Vyacheslav N Klochkov <[email protected]>

Author: v-klochkov

sycl/CMakeLists.txt

@@ -9,6 +9,9 @@ set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
 if(MSVC)
   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+  # Skip asynchronous C++ exceptions catching and assume "extern C" functions
+  # never throw C++ exceptions.
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
 endif()
 
 # Get clang's version

sycl/include/CL/sycl/detail/aligned_allocator.hpp

@@ -10,6 +10,7 @@
 
 #include <CL/cl.h>
 #include <CL/sycl/detail/cnri.h>
+#include <CL/sycl/detail/os_util.hpp>
 #include <CL/sycl/range.hpp>
 
 #include <cstring>
@@ -49,7 +50,7 @@ class aligned_allocator {
   pointer allocate(size_t Size) {
     Size += Alignment - Size % Alignment;
     pointer Result = reinterpret_cast<pointer>(
-      aligned_alloc(Alignment, Size * sizeof(value_type)));
+      detail::OSUtil::alignedAlloc(Alignment, Size * sizeof(value_type)));
     if (!Result)
       throw std::bad_alloc();
     return Result;
@@ -58,7 +59,7 @@ class aligned_allocator {
   // Release allocated memory
   void deallocate(pointer Ptr, size_t size) {
     if (Ptr)
-      free(Ptr);
+      detail::OSUtil::alignedFree(Ptr);
   }
 
   bool operator==(const aligned_allocator&) { return true; }

sycl/include/CL/sycl/detail/os_util.hpp

@@ -53,6 +53,13 @@ class OSUtil {
 
   /// Returns the amount of RAM available for the operating system.
   static size_t getOSMemSize();
+
+  /// Allocates \p NumBytes bytes of uninitialized storage whose alignment
+  /// is specified by \p Alignment.
+  static void *alignedAlloc(size_t Alignment, size_t NumBytes);
+
+  /// Deallocates the memory referenced by \p Ptr.
+  static void alignedFree(void *Ptr);
 };
 
 } // namespace detail

sycl/include/CL/sycl/detail/platform_util.hpp

@@ -10,6 +10,11 @@
 
 #include <cstdint>
 
+#ifdef _MSC_VER
+// This feature is not supported in MSVC.
+#define __builtin_expect(a, b) (a)
+#endif
+
 namespace cl {
 namespace sycl {
 namespace detail {
@@ -33,6 +38,8 @@ struct PlatformUtil {
   static uint32_t getMemCacheLineSize();
 
   static uint64_t getMemCacheSize();
+
+  static void prefetch(const char *Ptr, size_t NumBytes);
 };
 
 } // namespace detail

sycl/include/CL/sycl/multi_ptr.hpp

@@ -254,12 +254,8 @@ template <typename ElementType, access::address_space Space> class multi_ptr {
                 Space == access::address_space::global_space>::type>
   void prefetch(size_t NumElements) const {
     size_t NumBytes = NumElements * sizeof(ElementType);
-#ifdef __SYCL_DEVICE_ONLY__
-    auto PrefetchPtr = reinterpret_cast<const __global char *>(m_Pointer);
-#else
-    auto PrefetchPtr = reinterpret_cast<const char *>(m_Pointer);
-#endif
-    __spirv_ocl_prefetch(PrefetchPtr, NumBytes);
+    using ptr_t = typename detail::PtrValueType<char, Space>::type const *;
+    __spirv_ocl_prefetch(reinterpret_cast<ptr_t>(m_Pointer), NumBytes);
   }
 
 private:

sycl/source/detail/os_util.cpp

@@ -22,7 +22,7 @@
 #elif defined(SYCL_RT_OS_WINDOWS)
 
 #include <Windows.h>
-
+#include <malloc.h>
 #endif
 
 namespace cl {
@@ -90,6 +90,22 @@ size_t OSUtil::getOSMemSize() {
 #endif
 }
 
+void *OSUtil::alignedAlloc(size_t Alignment, size_t NumBytes) {
+#if defined(SYCL_RT_OS_LINUX)
+  return aligned_alloc(Alignment, NumBytes);
+#elif defined(SYCL_RT_OS_WINDOWS)
+  return _aligned_malloc(NumBytes, Alignment);
+#endif
+}
+
+void OSUtil::alignedFree(void *Ptr) {
+#if defined(SYCL_RT_OS_LINUX)
+  free(Ptr);
+#elif defined(SYCL_RT_OS_WINDOWS)
+  _aligned_free(Ptr);
+#endif
+}
+
 } // namespace detail
 } // namespace sycl
 } // namespace cl

sycl/source/detail/platform_util.cpp

@@ -120,6 +120,27 @@ uint32_t PlatformUtil::getNativeVectorWidth(PlatformUtil::TypeIndex TIndex) {
   return VECTOR_WIDTH_SSE42[Index];
 }
 
+void PlatformUtil::prefetch(const char *Ptr, size_t NumBytes) {
+  if (!Ptr)
+    return;
+
+  // The current implementation assumes 64-byte x86 cache lines.
+  const size_t CacheLineSize = 64;
+  const size_t CacheLineMask = ~(CacheLineSize - 1);
+  const char *PtrEnd = Ptr + NumBytes;
+
+  // Set the pointer to the beginning of the current cache line.
+  Ptr = reinterpret_cast<const char *>(
+            reinterpret_cast<size_t>(Ptr) & CacheLineMask);
+  for (; Ptr < PtrEnd; Ptr += CacheLineSize) {
+#if defined(SYCL_RT_OS_LINUX)
+    __builtin_prefetch(Ptr);
+#elif defined(SYCL_RT_OS_WINDOWS)
+    _mm_prefetch(Ptr, _MM_HINT_T0);
+#endif
+  }
+}
+
 } // namespace detail
 } // namespace sycl
 } // namespace cl

sycl/source/spirv_ops.cpp

@@ -8,6 +8,7 @@
 
 #include <CL/__spirv/spirv_ops.hpp>
 #include <CL/sycl/exception.hpp>
+#include <CL/sycl/detail/platform_util.hpp>
 #include <atomic>
 
 // This operation is NOP on HOST as all operations there are blocking and
@@ -32,12 +33,5 @@ void __spirv_MemoryBarrier(Scope Memory, uint32_t Semantics) noexcept {
 }
 
 void __spirv_ocl_prefetch(const char *Ptr, size_t NumBytes) noexcept {
-  // TODO: the cache line size may be different.
-  const size_t CacheLineSize = 64;
-  size_t NumCacheLines =
-      (NumBytes / CacheLineSize) + ((NumBytes % CacheLineSize) ? 1 : 0);
-  for (; NumCacheLines != 0; NumCacheLines--) {
-    __builtin_prefetch(reinterpret_cast<const void *>(Ptr));
-    Ptr += 64;
-  }
+  cl::sycl::detail::PlatformUtil::prefetch(Ptr, NumBytes);
 }