Fix several misc issues in device memory sanitizer (#18026)

* Disable inserting unreachable instruction since we have another
  mechanism to exit current kernel execution.
* Cleanup clean shadow after it's allocated.
* Remove redzone maximum limitation.

Author: zhaomaosu

source/loader/layers/sanitizer/msan/msan_interceptor.cpp

@@ -479,6 +479,9 @@ ur_result_t MsanInterceptor::prepareLaunch(
   UR_CALL(getContext()->urDdiTable.USM.pfnDeviceAlloc(
       ContextInfo->Handle, DeviceInfo->Handle, nullptr, nullptr,
       ContextInfo->MaxAllocatedSize, (void **)&LaunchInfo.Data->CleanShadow));
+  UR_CALL(EnqueueUSMBlockingSet(Queue, (void *)LaunchInfo.Data->CleanShadow, 0,
+                                ContextInfo->MaxAllocatedSize, 0, nullptr,
+                                nullptr));
 
   if (LaunchInfo.LocalWorkSize.empty()) {
     LaunchInfo.LocalWorkSize.resize(LaunchInfo.WorkDim);

source/loader/layers/sanitizer/sanitizer_common/sanitizer_common.hpp

@@ -34,6 +34,21 @@ inline constexpr bool IsPowerOfTwo(uptr x) {
   return (x & (x - 1)) == 0 && x != 0;
 }
 
+inline constexpr uptr RoundUpToPowerOfTwo(uptr x) {
+  if (x == 0)
+    return 1;
+  x--;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  x |= x >> 32;
+  x++;
+  assert(IsPowerOfTwo(x));
+  return x;
+}
+
 inline constexpr uptr RoundUpTo(uptr Size, uptr boundary) {
   assert(IsPowerOfTwo(boundary));
   return (Size + boundary - 1) & ~(boundary - 1);
@@ -48,16 +63,12 @@ inline constexpr bool IsAligned(uptr a, uptr alignment) {
   return (a & (alignment - 1)) == 0;
 }
 
-// Valid redzone sizes are 16, 32, 64, ... 2048, so we encode them in 3 bits.
+// Valid redzone sizes are 16, 32, 64 ..., so we encode them in 3 bits.
 // We use adaptive redzones: for larger allocation larger redzones are used.
-inline constexpr uptr RZLog2Size(uptr rz_log) {
-  assert(rz_log < 8);
-  return 16 << rz_log;
-}
+inline constexpr uptr RZLog2Size(uptr rz_log) { return 16 << rz_log; }
 
 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));

source/loader/layers/sanitizer/sanitizer_common/sanitizer_options.cpp

@@ -12,6 +12,7 @@
  */
 
 #include "sanitizer_options.hpp"
+#include "sanitizer_common.hpp"
 #include "sanitizer_options_impl.hpp"
 
 #include <cstring>
@@ -47,7 +48,13 @@ void SanitizerOptions::Init(const std::string &EnvName,
   Parser.ParseBool("halt_on_error", HaltOnError);
 
   Parser.ParseUint64("quarantine_size_mb", MaxQuarantineSizeMB, 0, UINT32_MAX);
-  Parser.ParseUint64("redzone", MinRZSize, 16, 2048);
+  Parser.ParseUint64("redzone", MinRZSize, 16);
+  MinRZSize =
+      IsPowerOfTwo(MinRZSize) ? MinRZSize : RoundUpToPowerOfTwo(MinRZSize);
+  if (MinRZSize > 16) {
+    Logger.warning(
+        "Increasing the redzone size may cause excessive memory overhead");
+  }
 }
 
 } // namespace ur_sanitizer_layer