sycn with latest code

Author: AllanZyne

source/loader/layers/sanitizer/asan_allocator.cpp

@@ -17,9 +17,9 @@ namespace ur_sanitizer_layer {
 
 void AllocInfo::print() {
     context.logger.info(
-        "AllocInfo(AllocBegin={},  User={}-{}, AllocSize={}, Type={})",
-        (void *)AllocBegin, (void *)UserBegin, (void *)UserEnd, AllocSize,
-        ToString(Type));
+        "AllocInfo(Alloc=[{}-{}),  User=[{}-{}), AllocSize={}, Type={})",
+        (void *)AllocBegin, (void *)(AllocBegin + AllocSize), (void *)UserBegin,
+        (void *)(UserEnd), AllocSize, ToString(Type));
 }
 
 } // namespace ur_sanitizer_layer

source/loader/layers/sanitizer/asan_interceptor.cpp

@@ -13,8 +13,8 @@
 #pragma once
 
 #include "asan_allocator.hpp"
+#include "asan_libdevice.hpp"
 #include "common.hpp"
-#include "device_sanitizer_report.hpp"
 #include "ur_sanitizer_layer.hpp"
 
 #include <memory>
@@ -61,7 +61,8 @@ struct DeviceInfo {
 
 struct QueueInfo {
     ur_queue_handle_t Handle;
-    ur_mutex Mutex;
+
+    ur_shared_mutex Mutex;
     ur_event_handle_t LastEvent;
 
     explicit QueueInfo(ur_queue_handle_t Queue)
@@ -112,9 +113,14 @@ struct LaunchInfo {
     DeviceSanitizerReport SPIR_DeviceSanitizerReportMem;
 
     ur_context_handle_t Context = nullptr;
-    size_t LocalWorkSize[3] = {0};
-
-    explicit LaunchInfo(ur_context_handle_t Context);
+    const size_t *GlobalWorkSize = nullptr;
+    const size_t *GlobalWorkOffset = nullptr;
+    std::vector<size_t> LocalWorkSize;
+    uint32_t WorkDim = 0;
+
+    LaunchInfo(ur_context_handle_t Context, const size_t *GlobalWorkSize,
+               const size_t *LocalWorkSize, const size_t *GlobalWorkOffset,
+               uint32_t WorkDim);
     ~LaunchInfo();
 };
 
@@ -134,17 +140,20 @@ class SanitizerInterceptor {
                                ur_device_handle_t Device,
                                const ur_usm_desc_t *Properties,
                                ur_usm_pool_handle_t Pool, size_t Size,
-                               void **ResultPtr, AllocType Type);
+                               AllocType Type, void **ResultPtr);
     ur_result_t releaseMemory(ur_context_handle_t Context, void *Ptr);
 
     ur_result_t registerDeviceGlobals(ur_context_handle_t Context,
                                       ur_program_handle_t Program);
 
     ur_result_t preLaunchKernel(ur_kernel_handle_t Kernel,
-                                ur_queue_handle_t Queue, LaunchInfo &LaunchInfo,
-                                uint32_t numWorkgroup);
-    void postLaunchKernel(ur_kernel_handle_t Kernel, ur_queue_handle_t Queue,
-                          ur_event_handle_t &Event, LaunchInfo &LaunchInfo);
+                                ur_queue_handle_t Queue,
+                                LaunchInfo &LaunchInfo);
+
+    ur_result_t postLaunchKernel(ur_kernel_handle_t Kernel,
+                                 ur_queue_handle_t Queue,
+                                 ur_event_handle_t &Event,
+                                 LaunchInfo &LaunchInfo);
 
     ur_result_t insertContext(ur_context_handle_t Context,
                               std::shared_ptr<ContextInfo> &CI);
@@ -156,6 +165,12 @@ class SanitizerInterceptor {
 
     std::optional<AllocationIterator> findAllocInfoByAddress(uptr Address);
 
+    std::shared_ptr<ContextInfo> getContextInfo(ur_context_handle_t Context) {
+        std::shared_lock<ur_shared_mutex> Guard(m_ContextMapMutex);
+        assert(m_ContextMap.find(Context) != m_ContextMap.end());
+        return m_ContextMap[Context];
+    }
+
   private:
     ur_result_t updateShadowMemory(std::shared_ptr<ContextInfo> &ContextInfo,
                                    std::shared_ptr<DeviceInfo> &DeviceInfo,
@@ -169,8 +184,8 @@ class SanitizerInterceptor {
     ur_result_t prepareLaunch(ur_context_handle_t Context,
                               std::shared_ptr<DeviceInfo> &DeviceInfo,
                               ur_queue_handle_t Queue,
-                              ur_kernel_handle_t Kernel, LaunchInfo &LaunchInfo,
-                              uint32_t numWorkgroup);
+                              ur_kernel_handle_t Kernel,
+                              LaunchInfo &LaunchInfo);
 
     ur_result_t allocShadowMemory(ur_context_handle_t Context,
                                   std::shared_ptr<DeviceInfo> &DeviceInfo);
@@ -179,12 +194,6 @@ class SanitizerInterceptor {
                                     ur_queue_handle_t Queue, uptr Addr,
                                     uptr Size, u8 Value);
 
-    std::shared_ptr<ContextInfo> getContextInfo(ur_context_handle_t Context) {
-        std::shared_lock<ur_shared_mutex> Guard(m_ContextMapMutex);
-        assert(m_ContextMap.find(Context) != m_ContextMap.end());
-        return m_ContextMap[Context];
-    }
-
     std::shared_ptr<DeviceInfo> getDeviceInfo(ur_device_handle_t Device) {
         std::shared_lock<ur_shared_mutex> Guard(m_DeviceMapMutex);
         assert(m_DeviceMap.find(Device) != m_DeviceMap.end());
@@ -206,6 +215,7 @@ class SanitizerInterceptor {
 
     uint64_t cl_Debug = 0;
     uint32_t cl_MaxQuarantineSizeMB = 0;
+    bool cl_DetectLocals = true;
 
     std::unique_ptr<Quarantine> m_Quarantine;
 };

source/loader/layers/sanitizer/asan_interceptor.hpp

@@ -23,6 +23,7 @@ enum class DeviceSanitizerErrorType : int32_t {
     USE_AFTER_FREE,
     OUT_OF_SHADOW_BOUNDS,
     UNKNOWN_DEVICE,
+    NULL_POINTER,
 };
 
 enum class DeviceSanitizerMemoryType : int32_t {
@@ -39,8 +40,8 @@ enum class DeviceSanitizerMemoryType : int32_t {
 struct DeviceSanitizerReport {
     int Flag = 0;
 
-    char File[256 + 1] = "";
-    char Func[256 + 1] = "";
+    char File[256 + 1] = {};
+    char Func[256 + 1] = {};
 
     int32_t Line = 0;
 
@@ -52,15 +53,53 @@ struct DeviceSanitizerReport {
     uint64_t LID1 = 0;
     uint64_t LID2 = 0;
 
-    uint64_t Addr = 0;
+    uintptr_t Address = 0;
     bool IsWrite = false;
     uint32_t AccessSize = 0;
-    DeviceSanitizerMemoryType MemoryType;
-    DeviceSanitizerErrorType ErrorType;
+    DeviceSanitizerMemoryType MemoryType = DeviceSanitizerMemoryType::UNKNOWN;
+    DeviceSanitizerErrorType ErrorType = DeviceSanitizerErrorType::UNKNOWN;
 
     bool IsRecover = false;
 };
 
+constexpr unsigned ASAN_SHADOW_SCALE = 3;
+constexpr unsigned ASAN_SHADOW_GRANULARITY = 1ULL << ASAN_SHADOW_SCALE;
+
+// Based on the observation, only the last 24 bits of the address of the private
+// variable have changed, we use 31 bits(2G) to be safe.
+constexpr std::size_t ASAN_PRIVATE_SIZE = 0x7fffffffULL + 1;
+
+// These magic values are written to shadow for better error
+// reporting.
+constexpr int kUsmDeviceRedzoneMagic = (char)0x81;
+constexpr int kUsmHostRedzoneMagic = (char)0x82;
+constexpr int kUsmSharedRedzoneMagic = (char)0x83;
+constexpr int kMemBufferRedzoneMagic = (char)0x84;
+constexpr int kDeviceGlobalRedzoneMagic = (char)0x85;
+constexpr int kNullPointerRedzoneMagic = (char)0x86;
+
+constexpr int kUsmDeviceDeallocatedMagic = (char)0x91;
+constexpr int kUsmHostDeallocatedMagic = (char)0x92;
+constexpr int kUsmSharedDeallocatedMagic = (char)0x93;
+constexpr int kMemBufferDeallocatedMagic = (char)0x93;
+
+constexpr int kSharedLocalRedzoneMagic = (char)0xa1;
+
+// Same with host ASan stack
+const int kPrivateLeftRedzoneMagic = (char)0xf1;
+const int kPrivateMidRedzoneMagic = (char)0xf2;
+const int kPrivateRightRedzoneMagic = (char)0xf3;
+
+constexpr auto kSPIR_AsanShadowMemoryGlobalStart =
+    "__AsanShadowMemoryGlobalStart";
+constexpr auto kSPIR_AsanShadowMemoryGlobalEnd = "__AsanShadowMemoryGlobalEnd";
+
+constexpr auto kSPIR_DeviceType = "__DeviceType";
+constexpr auto kSPIR_AsanDebug = "__AsanDebug";
+
+constexpr auto kSPIR_AsanDeviceGlobalCount = "__AsanDeviceGlobalCount";
+constexpr auto kSPIR_AsanDeviceGlobalMetadata = "__AsanDeviceGlobalMetadata";
+
 inline const char *ToString(DeviceSanitizerMemoryType MemoryType) {
     switch (MemoryType) {
     case DeviceSanitizerMemoryType::USM_DEVICE:
@@ -94,6 +133,8 @@ inline const char *ToString(DeviceSanitizerErrorType ErrorType) {
         return "out-of-shadow-bounds-access";
     case DeviceSanitizerErrorType::UNKNOWN_DEVICE:
         return "unknown-device";
+    case DeviceSanitizerErrorType::NULL_POINTER:
+        return "null-pointer-access";
     default:
         return "unknown-error";
     }

source/loader/layers/sanitizer/device_sanitizer_report.hpp renamed to source/loader/layers/sanitizer/asan_libdevice.hpp

@@ -18,8 +18,10 @@ std::vector<AllocationIterator> Quarantine::put(ur_device_handle_t Device,
                                                 AllocationIterator &It) {
     auto &AI = It->second;
     auto AllocSize = AI->AllocSize;
-    auto &Cache = m_Map[Device];
+    auto &Cache = getCache(Device);
+
     std::vector<AllocationIterator> DequeueList;
+    std::scoped_lock<ur_mutex> Guard(Cache.Mutex);
     while (Cache.size() + AllocSize > m_MaxQuarantineSize) {
         auto ElementOp = Cache.dequeue();
         if (!ElementOp) {

source/loader/layers/sanitizer/asan_quarantine.cpp

@@ -26,7 +26,8 @@ class QuarantineCache {
     using Element = AllocationIterator;
     using List = std::queue<Element>;
 
-    explicit QuarantineCache() {}
+    // The following methods are not thread safe, use this lock
+    ur_mutex Mutex;
 
     // Total memory used, including internal accounting.
     uptr size() const { return m_Size; }
@@ -62,7 +63,13 @@ class Quarantine {
                                         AllocationIterator &Ptr);
 
   private:
+    QuarantineCache &getCache(ur_device_handle_t Device) {
+        std::scoped_lock<ur_mutex> Guard(m_Mutex);
+        return m_Map[Device];
+    }
+
     std::unordered_map<ur_device_handle_t, QuarantineCache> m_Map;
+    ur_mutex m_Mutex;
     size_t m_MaxQuarantineSize;
 };
 

source/loader/layers/sanitizer/asan_quarantine.hpp

@@ -11,9 +11,10 @@
  */
 
 #include "asan_report.hpp"
+
 #include "asan_allocator.hpp"
 #include "asan_interceptor.hpp"
-#include "device_sanitizer_report.hpp"
+#include "asan_libdevice.hpp"
 #include "ur_sanitizer_layer.hpp"
 #include "ur_sanitizer_utils.hpp"
 
@@ -35,7 +36,7 @@ void ReportBadFree(uptr Addr, const StackTrace &stack,
 
     context.logger.always("{} is located inside of {} region [{}, {})",
                           (void *)Addr, ToString(AI->Type),
-                          (void *)AI->UserBegin, (void *)(AI->UserEnd + 1));
+                          (void *)AI->UserBegin, (void *)AI->UserEnd);
     context.logger.always("allocated here:");
     AI->AllocStack.print();
 
@@ -51,7 +52,7 @@ void ReportBadContext(uptr Addr, const StackTrace &stack,
 
     context.logger.always("{} is located inside of {} region [{}, {})",
                           (void *)Addr, ToString(AI->Type),
-                          (void *)AI->UserBegin, (void *)(AI->UserEnd + 1));
+                          (void *)AI->UserBegin, (void *)AI->UserEnd);
     context.logger.always("allocated here:");
     AI->AllocStack.print();
 
@@ -72,7 +73,7 @@ void ReportDoubleFree(uptr Addr, const StackTrace &Stack,
 
     context.logger.always("{} is located inside of {} region [{}, {})",
                           (void *)Addr, ToString(AI->Type),
-                          (void *)AI->UserBegin, (void *)(AI->UserEnd + 1));
+                          (void *)AI->UserBegin, (void *)AI->UserEnd);
     context.logger.always("freed here:");
     AI->ReleaseStack.print();
     context.logger.always("previously allocated here:");
@@ -120,7 +121,7 @@ void ReportUseAfterFree(const DeviceSanitizerReport &Report,
     KernelName = DemangleName(KernelName);
 
     context.logger.always("\n====ERROR: DeviceSanitizer: {} on address {}",
-                          ToString(Report.ErrorType), (void *)Report.Addr);
+                          ToString(Report.ErrorType), (void *)Report.Address);
     context.logger.always(
         "{} of size {} at kernel <{}> LID({}, {}, {}) GID({}, "
         "{}, {})",
@@ -131,24 +132,24 @@ void ReportUseAfterFree(const DeviceSanitizerReport &Report,
     context.logger.always("");
 
     auto AllocInfoItOp =
-        context.interceptor->findAllocInfoByAddress(Report.Addr);
+        context.interceptor->findAllocInfoByAddress(Report.Address);
     if (!AllocInfoItOp) {
         context.logger.always("Failed to find which chunck {} is allocated",
-                              (void *)Report.Addr);
+                              (void *)Report.Address);
         return;
     }
 
     auto &AllocInfo = (*AllocInfoItOp)->second;
     if (AllocInfo->Context != Context) {
         context.logger.always("Failed to find which chunck {} is allocated",
-                              (void *)Report.Addr);
+                              (void *)Report.Address);
     }
     assert(AllocInfo->IsReleased);
 
     context.logger.always("{} is located inside of {} region [{}, {})",
-                          (void *)Report.Addr, ToString(AllocInfo->Type),
+                          (void *)Report.Address, ToString(AllocInfo->Type),
                           (void *)AllocInfo->UserBegin,
-                          (void *)(AllocInfo->UserEnd + 1));
+                          (void *)AllocInfo->UserEnd);
     context.logger.always("allocated here:");
     AllocInfo->AllocStack.print();
     context.logger.always("released here:");

source/loader/layers/sanitizer/asan_report.cpp

@@ -28,9 +28,6 @@ using uptr = uintptr_t;
 using u8 = unsigned char;
 using u32 = unsigned int;
 
-constexpr unsigned ASAN_SHADOW_SCALE = 3;
-constexpr unsigned ASAN_SHADOW_GRANULARITY = 1ULL << ASAN_SHADOW_SCALE;
-
 inline constexpr bool IsPowerOfTwo(uptr x) {
     return (x & (x - 1)) == 0 && x != 0;
 }

source/loader/layers/sanitizer/common.hpp

@@ -58,7 +58,7 @@ __urdlllocal ur_result_t UR_APICALL urUSMHostAlloc(
     context.logger.debug("==== urUSMHostAlloc");
 
     return context.interceptor->allocateMemory(
-        hContext, nullptr, pUSMDesc, pool, size, ppMem, AllocType::HOST_USM);
+        hContext, nullptr, pUSMDesc, pool, size, AllocType::HOST_USM, ppMem);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -83,7 +83,7 @@ __urdlllocal ur_result_t UR_APICALL urUSMDeviceAlloc(
     context.logger.debug("==== urUSMDeviceAlloc");
 
     return context.interceptor->allocateMemory(
-        hContext, hDevice, pUSMDesc, pool, size, ppMem, AllocType::DEVICE_USM);
+        hContext, hDevice, pUSMDesc, pool, size, AllocType::DEVICE_USM, ppMem);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -108,7 +108,7 @@ __urdlllocal ur_result_t UR_APICALL urUSMSharedAlloc(
     context.logger.debug("==== urUSMSharedAlloc");
 
     return context.interceptor->allocateMemory(
-        hContext, hDevice, pUSMDesc, pool, size, ppMem, AllocType::SHARED_USM);
+        hContext, hDevice, pUSMDesc, pool, size, AllocType::SHARED_USM, ppMem);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -214,33 +214,19 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch(
 
     context.logger.debug("==== urEnqueueKernelLaunch");
 
-    LaunchInfo LaunchInfo(GetContext(hQueue));
-    const size_t *pUserLocalWorkSize = pLocalWorkSize;
-    if (!pUserLocalWorkSize) {
-        pUserLocalWorkSize = LaunchInfo.LocalWorkSize;
-        // FIXME: This is W/A until urKernelSuggestGroupSize is added
-        LaunchInfo.LocalWorkSize[0] = 1;
-        LaunchInfo.LocalWorkSize[1] = 1;
-        LaunchInfo.LocalWorkSize[2] = 1;
-    }
-
-    uint32_t numWork = 1;
-    for (uint32_t dim = 0; dim < workDim; ++dim) {
-        numWork *= (pGlobalWorkSize[dim] + pUserLocalWorkSize[dim] - 1) /
-                   pUserLocalWorkSize[dim];
-    }
+    LaunchInfo LaunchInfo(GetContext(hQueue), pGlobalWorkSize, pLocalWorkSize,
+                          pGlobalWorkOffset, workDim);
 
-    UR_CALL(context.interceptor->preLaunchKernel(hKernel, hQueue, LaunchInfo,
-                                                 numWork));
+    UR_CALL(context.interceptor->preLaunchKernel(hKernel, hQueue, LaunchInfo));
 
     ur_event_handle_t hEvent{};
     ur_result_t result = pfnKernelLaunch(
         hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize,
         pLocalWorkSize, numEventsInWaitList, phEventWaitList, &hEvent);
 
     if (result == UR_RESULT_SUCCESS) {
-        context.interceptor->postLaunchKernel(hKernel, hQueue, hEvent,
-                                              LaunchInfo);
+        UR_CALL(context.interceptor->postLaunchKernel(hKernel, hQueue, hEvent,
+                                                      LaunchInfo));
     }
 
     if (phEvent) {