Private/s kanaev/assert abort impl test

libdevice/atomic.hpp

@@ -0,0 +1,95 @@
+//==-------------- atomic.hpp - support of atomic operations ---------------==//
+//
+// 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 <cstdint>
+
+#include "device.h"
+
+#ifdef __SPIR__
+
+#define __SYCL_GLOBAL__ __attribute__((opencl_global))
+
+namespace __spv {
+struct Scope {
+
+  enum Flag : uint32_t {
+    CrossDevice = 0,
+    Device = 1,
+    Workgroup = 2,
+    Subgroup = 3,
+    Invocation = 4,
+  };
+
+  constexpr Scope(Flag flag) : flag_value(flag) {}
+
+  constexpr operator uint32_t() const { return flag_value; }
+
+  Flag flag_value;
+};
+
+struct MemorySemanticsMask {
+
+  enum Flag : uint32_t {
+    None = 0x0,
+    Acquire = 0x2,
+    Release = 0x4,
+    AcquireRelease = 0x8,
+    SequentiallyConsistent = 0x10,
+    UniformMemory = 0x40,
+    SubgroupMemory = 0x80,
+    WorkgroupMemory = 0x100,
+    CrossWorkgroupMemory = 0x200,
+    AtomicCounterMemory = 0x400,
+    ImageMemory = 0x800,
+  };
+
+  constexpr MemorySemanticsMask(Flag flag) : flag_value(flag) {}
+
+  constexpr operator uint32_t() const { return flag_value; }
+
+  Flag flag_value;
+};
+} // namespace __spv
+
+extern DEVICE_EXTERNAL int
+__spirv_AtomicCompareExchange(int __SYCL_GLOBAL__ *, __spv::Scope::Flag,
+                              __spv::MemorySemanticsMask::Flag,
+                              __spv::MemorySemanticsMask::Flag, int, int);
+
+extern DEVICE_EXTERNAL int __spirv_AtomicLoad(const int __SYCL_GLOBAL__ *,
+                                              __spv::Scope::Flag,
+                                              __spv::MemorySemanticsMask::Flag);
+
+extern DEVICE_EXTERNAL int __spirv_AtomicStore(int __SYCL_GLOBAL__ *,
+                                               __spv::Scope::Flag,
+                                               __spv::MemorySemanticsMask::Flag,
+                                               int);
+
+/// Atomically set the value in *Ptr with Desired if and only if it is Expected
+/// Return the value which already was in *Ptr
+static inline int atomicCompareAndSet(__SYCL_GLOBAL__ int *Ptr, int Desired,
+                                      int Expected) {
+  return __spirv_AtomicCompareExchange(
+      Ptr, __spv::Scope::Device,
+      __spv::MemorySemanticsMask::SequentiallyConsistent,
+      __spv::MemorySemanticsMask::SequentiallyConsistent, Desired, Expected);
+}
+
+static inline int atomicLoad(__SYCL_GLOBAL__ int *Ptr) {
+  return __spirv_AtomicLoad(Ptr, __spv::Scope::Device,
+                            __spv::MemorySemanticsMask::SequentiallyConsistent);
+}
+
+static inline int atomicStore(__SYCL_GLOBAL__ int *Ptr, int V) {
+  return __spirv_AtomicStore(Ptr, __spv::Scope::Device,
+                             __spv::MemorySemanticsMask::SequentiallyConsistent,
+                             V);
+}
+
+#endif // __SPIR__

libdevice/fallback-cassert.cpp

@@ -6,26 +6,97 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "atomic.hpp"
+#include "include/assert-happened.hpp"
 #include "wrapper.h"
 
 #ifdef __SPIR__
+
+#define ASSERT_NONE 0
+#define ASSERT_START 1
+#define ASSERT_FINISH 2
+
+// definition
+__SYCL_GLOBAL__ AssertHappened __SYCL_AssertHappenedMem;
+
 static const __attribute__((opencl_constant)) char assert_fmt[] =
     "%s:%d: %s: global id: [%lu,%lu,%lu], local id: [%lu,%lu,%lu] "
     "Assertion `%s` failed.\n";
 
+DEVICE_EXTERN_C void __devicelib_assert_read(void *_Dst) {
+  AssertHappened *Dst = (AssertHappened *)_Dst;
+  int Flag = atomicLoad(&__SYCL_AssertHappenedMem.Flag);
+
+  if (ASSERT_NONE == Flag) {
+    Dst->Flag = Flag;
+    return;
+  }
+
+  if (Flag != ASSERT_FINISH)
+    while (ASSERT_START == atomicLoad(&__SYCL_AssertHappenedMem.Flag))
+      ;
+
+  *Dst = __SYCL_AssertHappenedMem;
+}
+
 DEVICE_EXTERN_C void __devicelib_assert_fail(const char *expr, const char *file,
                                              int32_t line, const char *func,
                                              uint64_t gid0, uint64_t gid1,
                                              uint64_t gid2, uint64_t lid0,
                                              uint64_t lid1, uint64_t lid2) {
-  // intX_t types are used instead of `int' and `long' because the format string
-  // is defined in terms of *device* types (OpenCL types): %d matches a 32 bit
-  // integer, %lu matches a 64 bit unsigned integer. Host `int' and
-  // `long' types may be different, so we cannot use them.
-  __spirv_ocl_printf(assert_fmt, file, (int32_t)line,
-                     // WORKAROUND: IGC does not handle this well
-                     // (func) ? func : "<unknown function>",
-                     func, gid0, gid1, gid2, lid0, lid1, lid2, expr);
+  int Expected = ASSERT_NONE;
+  int Desired = ASSERT_START;
+
+  if (atomicCompareAndSet(&__SYCL_AssertHappenedMem.Flag, Desired, Expected) ==
+      Expected) {
+    __SYCL_AssertHappenedMem.Line = line;
+    __SYCL_AssertHappenedMem.GID0 = gid0;
+    __SYCL_AssertHappenedMem.GID1 = gid1;
+    __SYCL_AssertHappenedMem.GID2 = gid2;
+    __SYCL_AssertHappenedMem.LID0 = lid0;
+    __SYCL_AssertHappenedMem.LID1 = lid1;
+    __SYCL_AssertHappenedMem.LID2 = lid2;
+
+    int ExprLength = 0;
+    int FileLength = 0;
+    int FuncLength = 0;
+
+    if (expr)
+      for (const char *C = expr; *C != '\0'; ++C, ++ExprLength)
+        ;
+    if (file)
+      for (const char *C = file; *C != '\0'; ++C, ++FileLength)
+        ;
+    if (func)
+      for (const char *C = func; *C != '\0'; ++C, ++FuncLength)
+        ;
+
+    int MaxExprIdx = sizeof(__SYCL_AssertHappenedMem.Expr) - 1;
+    int MaxFileIdx = sizeof(__SYCL_AssertHappenedMem.File) - 1;
+    int MaxFuncIdx = sizeof(__SYCL_AssertHappenedMem.Func) - 1;
+
+    if (ExprLength < MaxExprIdx)
+      MaxExprIdx = ExprLength;
+    if (FileLength < MaxFileIdx)
+      MaxFileIdx = FileLength;
+    if (FuncLength < MaxFuncIdx)
+      MaxFuncIdx = FuncLength;
+
+    for (int Idx = 0; Idx < MaxExprIdx; ++Idx)
+      __SYCL_AssertHappenedMem.Expr[Idx] = expr[Idx];
+    __SYCL_AssertHappenedMem.Expr[MaxExprIdx] = '\0';
+
+    for (int Idx = 0; Idx < MaxFileIdx; ++Idx)
+      __SYCL_AssertHappenedMem.File[Idx] = file[Idx];
+    __SYCL_AssertHappenedMem.File[MaxFileIdx] = '\0';
+
+    for (int Idx = 0; Idx < MaxFuncIdx; ++Idx)
+      __SYCL_AssertHappenedMem.Func[Idx] = func[Idx];
+    __SYCL_AssertHappenedMem.Func[MaxFuncIdx] = '\0';
+
+    // Show we've done copying
+    atomicStore(&__SYCL_AssertHappenedMem.Flag, ASSERT_FINISH);
+  }
 
   // FIXME: call SPIR-V unreachable instead
   // volatile int *die = (int *)0x0;

libdevice/include/assert-happened.hpp

@@ -0,0 +1,42 @@
+//==-- assert-happened.hpp - Structure and declaration for assert support --==//
+//
+// 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
+
+// Treat this header as system one to workaround frontend's restriction
+#pragma clang system_header
+
+#ifdef __SPIR__
+
+struct AssertHappened {
+  int Flag = 0;
+  char Expr[256 + 1] = "";
+  char File[256 + 1] = "";
+  char Func[128 + 1] = "";
+
+  int32_t Line = 0;
+
+  uint64_t GID0 = 0;
+  uint64_t GID1 = 0;
+  uint64_t GID2 = 0;
+
+  uint64_t LID0 = 0;
+  uint64_t LID1 = 0;
+  uint64_t LID2 = 0;
+};
+
+#ifndef __SYCL_GLOBAL_VAR__
+#define __SYCL_GLOBAL_VAR__ __attribute__((sycl_global_var))
+#endif
+
+#define __SYCL_GLOBAL__ __attribute__((opencl_global))
+
+// declaration
+extern __SYCL_GLOBAL_VAR__ __SYCL_GLOBAL__ AssertHappened
+    __SYCL_AssertHappenedMem;
+
+#endif

sycl/cmake/modules/AddSYCLUnitTest.cmake

@@ -17,10 +17,14 @@ macro(add_sycl_unittest test_dirname link_variant)
   if ("${link_variant}" MATCHES "SHARED")
     set(SYCL_LINK_LIBS ${sycl_so_target})
     add_unittest(SYCLUnitTests ${test_dirname} ${ARGN})
+    target_compile_definitions(${test_dirname}
+                               PRIVATE SYCL_DISABLE_FALLBACK_ASSERT)
   else()
     add_unittest(SYCLUnitTests ${test_dirname}
                 $<TARGET_OBJECTS:${sycl_obj_target}> ${ARGN})
-    target_compile_definitions(${test_dirname} PRIVATE __SYCL_BUILD_SYCL_DLL)
+    target_compile_definitions(${test_dirname}
+                               PRIVATE __SYCL_BUILD_SYCL_DLL
+                                       SYCL_DISABLE_FALLBACK_ASSERT)
 
     get_target_property(SYCL_LINK_LIBS ${sycl_so_target} LINK_LIBRARIES)
   endif()
@@ -66,6 +70,7 @@ macro(add_sycl_unittest_with_device test_dirname link_variant)
     -DGTEST_LANG_CXX11=1
     -DGTEST_HAS_TR1_TUPLE=0
     -D__SYCL_BUILD_SYCL_DLL
+    -DSYCL_DISABLE_FALLBACK_ASSERT
     -I${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include
     -I${LLVM_MAIN_SRC_DIR}/utils/unittest/googlemock/include
     -I${LLVM_BINARY_DIR}/include

sycl/doc/Assert.md

@@ -172,18 +172,25 @@ same binary image where fallback `__devicelib_assert_fail` resides.
 declaration:</a>
 
 ```c++
-namespace cl {
-namespace sycl {
-namespace detail {
-struct AssertHappened {
+struct __SYCL_AssertHappened {
   int Flag = 0;
+  char Expr[256 + 1] = "";
+  char File[256 + 1] = "";
+  char Func[128 + 1] = "";
+
+  int32_t Line = 0;
+
+  uint64_t GID0 = 0;
+  uint64_t GID1 = 0;
+  uint64_t GID2 = 0;
+
+  uint64_t LID0 = 0;
+  uint64_t LID1 = 0;
+  uint64_t LID2 = 0;
 };
-}
-}
-}
 
 #ifdef __SYCL_DEVICE_ONLY__
-extern SYCL_GLOBAL_VAR AssertHappened AssertHappenedMem;
+extern SYCL_GLOBAL_VAR __SYCL_AssertHappened __SYCL_AssertHappenedMem;
 #endif
 ```
 
@@ -193,6 +200,28 @@ mutable program-scope variable.
 The reference to extern variable is resolved within online-linking against
 fallback devicelib.
 
+#### Description of fields
+
+The value stored here denotes if assert happened at all. There are two valid
+values at host:
+
+| Value | Meaning |
+| ----- | ------- |
+| 0     | No assert failure detected |
+| 2     | Assert failure detected and reported within this instance of struct |
+
+At device-side, there's another valid value: 1, which means that assert failure
+is detected and the structure is filling up at the moment. This value is for
+device-side only and should never be reported to host. Otherwise, it means, that
+atomic operation malfunctioned.
+
+`Expr`, `File`, `Func`, `Line` are to describe the assert message itself and
+contain the expression, file name, function name, line in the file where assert
+failure had happened respectively.
+
+`GID*` and `LID*` fields describe the global and local ID respectively of a
+work-item in which assert had failed.
+
 ### Online-linking fallback `__devicelib_assert_fail`
 
 Online linking against fallback implementation of `__devicelib_assert_fail` is

sycl/doc/PreprocessorMacros.md

@@ -33,6 +33,13 @@ SYCL 2020.
 
 Disables all deprecation warnings in SYCL runtime headers, including SYCL 1.2.1 deprecations.
 
+### `SYCL_DISABLE_FALLBACK_ASSERT`
+
+Forces fallback assert feature implementation disable i.e. the *copier kernel*
+and *checker host-task* are not enqueued. Also, DPCPP RT won't perform check if
+user's kernel uses `__devicelib_assert_fail`. Refer to [the document](Assert.md)
+for function behind *copier kernel* and *checker host-task*.
+
 ### Version macros
 
 - `__LIBSYCL_MAJOR_VERSION` is set to SYCL runtime library major version.

sycl/doc/extensions/C-CXX-StandardLibrary/DeviceLibExtensions.rst

@@ -14,13 +14,17 @@ cl_intel_devicelib_cassert
                                 __generic const char *func,
                                 size_t gid0, size_t gid1, size_t gid2,
                                 size_t lid0, size_t lid1, size_t lid2);
+
 Semantic:
 the function is called when an assertion expression `expr` is false,
 and it indicates that a program does not execute as expected.
 The function should print a message containing the information
 provided in the arguments. In addition to that, the function is free
 to terminate the current kernel invocation.
 
+Fallback implementation of the function raises a flag to be read later by `__devicelib_assert_read`.
+The flag remains raised until the program finishes.
+
 Arguments:
 
   - `expr` is a string representation of the assertion condition
@@ -33,6 +37,16 @@ Example of a message:
 .. code:
    foo.cpp:42: void foo(int): global id: [0,0,0], local id: [0,0,0] Assertion `buf[wiID] == 0 && "Invalid value"` failed.
 
+.. code:
+   int __devicelib_assert_read();
+
+Semantic:
+the function is called to read assert failure flag raised by
+`__devicelib_assert_fail`.
+The function is only used in fallback implementation.
+Invoking `__devicelib_assert_fail` after a kernel doesn't imply the kernel has
+assertion failed.
+
 See also: assert_extension_.
 .. _assert_extension: ../Assert/SYCL_ONEAPI_ASSERT.asciidoc)
 

sycl/include/CL/sycl/aspects.hpp

@@ -41,6 +41,7 @@ enum class aspect {
   ext_intel_mem_channel = 25,
   usm_atomic_host_allocations = 26,
   usm_atomic_shared_allocations = 27,
+  ext_oneapi_native_assert = 28,
 };
 
 } // namespace sycl