[DeviceSanitizer] Add options to allow user to customize red zone size

Author: zhaomaosu

source/loader/layers/sanitizer/asan_interceptor.cpp

@@ -155,6 +155,35 @@ SanitizerInterceptor::SanitizerInterceptor() {
         cl_Debug = Value == "1" || Value == "true" ? 1 : 0;
     }
 
+    KV = Options->find("redzone");
+    if (KV != Options->end()) {
+        auto Value = KV->second.front();
+        try {
+            cl_MinRZSize = std::stoul(Value);
+            if (cl_MinRZSize < 16) {
+                cl_MinRZSize = 16;
+                context.logger.warning("Trying to set redzone size to a value "
+                                       "less than 16 is ignored");
+            }
+        } catch (...) {
+            die("<SANITIZER>[ERROR]: \"redzone\" should be an integer");
+        }
+    }
+    KV = Options->find("max_redzone");
+    if (KV != Options->end()) {
+        auto Value = KV->second.front();
+        try {
+            cl_MaxRZSize = std::stoul(Value);
+            if (cl_MaxRZSize > 2048) {
+                cl_MaxRZSize = 2048;
+                context.logger.warning("Trying to set max redzone size to a "
+                                       "value greater than 2048 is ignored");
+            }
+        } catch (...) {
+            die("<SANITIZER>[ERROR]: \"max_redzone\" should be an integer");
+        }
+    }
+
     KV = Options->find("quarantine_size_mb");
     if (KV != Options->end()) {
         auto Value = KV->second.front();
@@ -213,7 +242,7 @@ ur_result_t SanitizerInterceptor::allocateMemory(
         Alignment = MinAlignment;
     }
 
-    uptr RZLog = ComputeRZLog(Size);
+    uptr RZLog = ComputeRZLog(Size, cl_MinRZSize, cl_MaxRZSize);
     uptr RZSize = RZLog2Size(RZLog);
     uptr RoundedSize = RoundUpTo(Size, Alignment);
     uptr NeededSize = RoundedSize + RZSize * 2;

source/loader/layers/sanitizer/asan_interceptor.hpp

@@ -221,6 +221,8 @@ class SanitizerInterceptor {
 
     // We use "uint64_t" here because EnqueueWriteGlobal will fail when it's "uint32_t"
     uint64_t cl_Debug = 0;
+    uint64_t cl_MinRZSize = 16;
+    uint64_t cl_MaxRZSize = 2048;
     uint32_t cl_MaxQuarantineSizeMB = 0;
     bool cl_DetectLocals = true;
 

source/loader/layers/sanitizer/common.hpp

@@ -16,6 +16,7 @@
 #include "ur_ddi.h"
 
 #include <cassert>
+#include <cmath>
 #include <cstdint>
 #include <string>
 
@@ -53,7 +54,17 @@ inline constexpr uptr RZLog2Size(uptr rz_log) {
     return 16 << rz_log;
 }
 
-inline constexpr uptr ComputeRZLog(uptr user_requested_size) {
+inline constexpr uptr RZSize2Log(uptr rz_size) {
+    assert(rz_size >= 16);
+    assert(rz_size <= 2048);
+    assert(IsPowerOfTwo(rz_size));
+    uptr res = log2(rz_size) - 4;
+    assert(rz_size == RZLog2Size(res));
+    return res;
+}
+
+inline constexpr uptr ComputeRZLog(uptr user_requested_size, uptr min_size,
+                                   uptr max_size) {
     uptr rz_log = user_requested_size <= 64 - 16            ? 0
                   : user_requested_size <= 128 - 32         ? 1
                   : user_requested_size <= 512 - 64         ? 2
@@ -62,7 +73,9 @@ inline constexpr uptr ComputeRZLog(uptr user_requested_size) {
                   : user_requested_size <= (1 << 15) - 512  ? 5
                   : user_requested_size <= (1 << 16) - 1024 ? 6
                                                             : 7;
-    return rz_log;
+    uptr min_log = RZSize2Log(min_size);
+    uptr max_log = RZSize2Log(max_size);
+    return std::min(std::max(rz_log, min_log), max_log);
 }
 
 // ================================================================

source/loader/layers/sanitizer/ur_sanitizer_layer.cpp

@@ -18,8 +18,8 @@ context_t context;
 
 ///////////////////////////////////////////////////////////////////////////////
 context_t::context_t()
-    : interceptor(std::make_unique<SanitizerInterceptor>()),
-      logger(logger::create_logger("sanitizer")) {}
+    : logger(logger::create_logger("sanitizer")),
+      interceptor(std::make_unique<SanitizerInterceptor>()) {}
 
 bool context_t::isAvailable() const { return true; }
 

source/loader/layers/sanitizer/ur_sanitizer_layer.hpp

@@ -32,8 +32,8 @@ enum class SanitizerType {
 class __urdlllocal context_t : public proxy_layer_context_t {
   public:
     ur_dditable_t urDdiTable = {};
-    std::unique_ptr<SanitizerInterceptor> interceptor;
     logger::Logger logger;
+    std::unique_ptr<SanitizerInterceptor> interceptor;
     SanitizerType enabledType = SanitizerType::None;
 
     context_t();