[DevTSAN] Support thread sanitizer for device offloading in UR & libdevice (#17345)

This PR is going to support thread sanitizer for device offloading (UR &
libdevice part)
  1.implemented builtin __tsan_[read|write]N
  2.added thread sanitizer layer in UR
  3.fallback __TsanLaunchInfo to device global due to GPU driver issue
  4.added three e2e tests

Author: zhaomaosu

libdevice/atomic.hpp

@@ -79,6 +79,11 @@ extern DEVICE_EXTERNAL void
 __spirv_AtomicStore(int *, __spv::Scope::Flag, __spv::MemorySemanticsMask::Flag,
                     int);
 
+extern DEVICE_EXTERNAL int __spirv_AtomicIAdd(SPIR_GLOBAL int *,
+                                              __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(SPIR_GLOBAL int *Ptr, int Desired,
@@ -111,4 +116,10 @@ static inline void atomicStore(int *Ptr, int V) {
                       __spv::MemorySemanticsMask::SequentiallyConsistent, V);
 }
 
+static inline int atomicAdd(SPIR_GLOBAL int *Ptr, int V) {
+  return __spirv_AtomicIAdd(Ptr, __spv::Scope::Device,
+                            __spv::MemorySemanticsMask::SequentiallyConsistent,
+                            V);
+}
+
 #endif // __SPIR__ || __SPIRV__

libdevice/cmake/modules/SYCLLibdevice.cmake

@@ -299,6 +299,14 @@ if (NOT MSVC AND UR_SANITIZER_INCLUDE_DIR)
     include/sanitizer_defs.hpp
     include/spir_global_var.hpp
     sycl-compiler)
+
+  set(tsan_obj_deps
+    device.h atomic.hpp spirv_vars.h
+    ${UR_SANITIZER_INCLUDE_DIR}/tsan/tsan_libdevice.hpp
+    include/tsan_rtl.hpp
+    include/sanitizer_defs.hpp
+    include/spir_global_var.hpp
+    sycl-compiler)
 endif()
 
 if("native_cpu" IN_LIST SYCL_ENABLE_BACKENDS)
@@ -393,6 +401,7 @@ else()
                  -I${UR_SANITIZER_INCLUDE_DIR}
                  -I${CMAKE_CURRENT_SOURCE_DIR})
 
+    # msan aot
     set(msan_devicetypes pvc cpu)
 
     foreach(msan_ft IN LISTS sanitizer_filetypes)
@@ -405,6 +414,13 @@ else()
       endforeach()
     endforeach()
 
+    # tsan jit
+    add_devicelibs(libsycl-tsan
+      SRC sanitizer/tsan_rtl.cpp
+      DEPENDENCIES ${tsan_obj_deps}
+      EXTRA_OPTS -fno-sycl-instrument-device-code
+                 -I${UR_SANITIZER_INCLUDE_DIR}
+                 -I${CMAKE_CURRENT_SOURCE_DIR})
   endif()
 endif()
 

libdevice/include/tsan_rtl.hpp

@@ -0,0 +1,67 @@
+//==-- tsan_rtl.hpp - Declaration for sanitizer global var ---==//
+//
+// 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 "sanitizer_defs.hpp"
+#include "spir_global_var.hpp"
+#include "tsan/tsan_libdevice.hpp"
+
+// Treat this header as system one to workaround frontend's restriction
+#pragma clang system_header
+
+#if defined(__SPIR__) || defined(__SPIRV__)
+
+struct Shadow {
+public:
+  static constexpr RawShadow kEmpty = static_cast<RawShadow>(0);
+
+  // A marker to indicate that the current address will not trigger race
+  // condition.
+  static constexpr RawShadow kRodata = static_cast<RawShadow>(1 << 30);
+
+  Shadow(uint32_t addr, uint32_t size, uint32_t clock, uint32_t sid,
+         AccessType typ) {
+    raw_ = 0;
+    raw_ |= (!!(typ & kAccessAtomic) << 31) | (!!(typ & kAccessRead) << 30) |
+            (clock << 16) | (sid << 8) |
+            (((((1u << size) - 1) << (addr & 0x7)) & 0xff));
+  }
+
+  explicit Shadow(RawShadow x = Shadow::kEmpty) {
+    raw_ = static_cast<uint32_t>(x);
+  }
+
+  RawShadow raw() const { return static_cast<RawShadow>(raw_); }
+
+  Sid sid() const { return part_.sid_; }
+
+  uint16_t clock() const { return part_.clock_; }
+
+  uint8_t access() const { return part_.access_; }
+
+  bool IsBothReads(AccessType Type) {
+    uint32_t is_read = !!(Type & kAccessRead);
+    bool res = raw_ & (is_read << 30);
+    return res;
+  }
+
+private:
+  struct Parts {
+    uint8_t access_;
+    Sid sid_;
+    uint16_t clock_ : 14;
+    uint16_t is_read_ : 1;
+    uint16_t is_atomic_ : 1;
+  };
+  union {
+    Parts part_;
+    uint32_t raw_;
+  };
+};
+
+#endif // __SPIR__ || __SPIRV__