Merge branch 'main' into buffer-migration

Author: zhaomaosu

source/adapters/opencl/device.cpp

@@ -938,28 +938,17 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return UR_RESULT_SUCCESS;
   }
   case UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL: {
-    /* CL_DEVICE_SUB_GROUP_SIZES_INTEL is only supported if the device has the
-     * cl_intel_required_subgroup_size extension.
-     * */
-    bool Supported = false;
-    CL_RETURN_ON_FAILURE(cl_adapter::checkDeviceExtensions(
-        cl_adapter::cast<cl_device_id>(hDevice),
-        {"cl_intel_required_subgroup_size"}, Supported));
-    if (Supported) {
-      // Have to convert size_t to uint32_t
-      size_t SubGroupSizesSize = 0;
-      CL_RETURN_ON_FAILURE(
-          clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CLPropName,
-                          0, nullptr, &SubGroupSizesSize));
-      std::vector<size_t> SubGroupSizes(SubGroupSizesSize / sizeof(size_t));
-      CL_RETURN_ON_FAILURE(
-          clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CLPropName,
-                          SubGroupSizesSize, SubGroupSizes.data(), nullptr));
-      return ReturnValue.template operator()<uint32_t>(SubGroupSizes.data(),
-                                                       SubGroupSizes.size());
-    } else {
-      return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
-    }
+    // Have to convert size_t to uint32_t
+    size_t SubGroupSizesSize = 0;
+    CL_RETURN_ON_FAILURE(
+        clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CLPropName, 0,
+                        nullptr, &SubGroupSizesSize));
+    std::vector<size_t> SubGroupSizes(SubGroupSizesSize / sizeof(size_t));
+    CL_RETURN_ON_FAILURE(
+        clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CLPropName,
+                        SubGroupSizesSize, SubGroupSizes.data(), nullptr));
+    return ReturnValue.template operator()<uint32_t>(SubGroupSizes.data(),
+                                                     SubGroupSizes.size());
   }
   case UR_DEVICE_INFO_EXTENSIONS: {
     cl_device_id Dev = cl_adapter::cast<cl_device_id>(hDevice);

source/loader/layers/sanitizer/asan_interceptor.cpp

@@ -146,10 +146,12 @@ ur_result_t enqueueMemSetShadow(ur_context_handle_t Context,
 
 } // namespace
 
-SanitizerInterceptor::SanitizerInterceptor() {
-    if (Options().MaxQuarantineSizeMB) {
+SanitizerInterceptor::SanitizerInterceptor(logger::Logger &logger)
+    : logger(logger) {
+    if (Options(logger).MaxQuarantineSizeMB) {
         m_Quarantine = std::make_unique<Quarantine>(
-            static_cast<uint64_t>(Options().MaxQuarantineSizeMB) * 1024 * 1024);
+            static_cast<uint64_t>(Options(logger).MaxQuarantineSizeMB) * 1024 *
+            1024);
     }
 }
 
@@ -189,7 +191,8 @@ ur_result_t SanitizerInterceptor::allocateMemory(
         Alignment = MinAlignment;
     }
 
-    uptr RZLog = ComputeRZLog(Size, Options().MinRZSize, Options().MaxRZSize);
+    uptr RZLog = ComputeRZLog(Size, Options(logger).MinRZSize,
+                              Options(logger).MaxRZSize);
     uptr RZSize = RZLog2Size(RZLog);
     uptr RoundedSize = RoundUpTo(Size, Alignment);
     uptr NeededSize = RoundedSize + RZSize * 2;
@@ -706,7 +709,7 @@ ur_result_t SanitizerInterceptor::prepareLaunch(
 
         // Write debug
         // We use "uint64_t" here because EnqueueWriteGlobal will fail when it's "uint32_t"
-        uint64_t Debug = Options().Debug ? 1 : 0;
+        uint64_t Debug = Options(logger).Debug ? 1 : 0;
         EnqueueWriteGlobal(kSPIR_AsanDebug, &Debug, sizeof(Debug));
 
         // Write shadow memory offset for global memory
@@ -779,7 +782,7 @@ ur_result_t SanitizerInterceptor::prepareLaunch(
             LocalMemoryUsage, PrivateMemoryUsage);
 
         // Write shadow memory offset for local memory
-        if (Options().DetectLocals) {
+        if (Options(logger).DetectLocals) {
             // CPU needn't this
             if (DeviceInfo->Type == DeviceType::GPU_PVC) {
                 const size_t LocalMemorySize =
@@ -818,7 +821,7 @@ ur_result_t SanitizerInterceptor::prepareLaunch(
         }
 
         // Write shadow memory offset for private memory
-        if (Options().DetectPrivates) {
+        if (Options(logger).DetectPrivates) {
             if (DeviceInfo->Type == DeviceType::CPU) {
                 LaunchInfo.Data->PrivateShadowOffset = DeviceInfo->ShadowOffset;
             } else if (DeviceInfo->Type == DeviceType::GPU_PVC) {

source/loader/layers/sanitizer/asan_interceptor.hpp

@@ -164,7 +164,7 @@ struct DeviceGlobalInfo {
 
 class SanitizerInterceptor {
   public:
-    explicit SanitizerInterceptor();
+    explicit SanitizerInterceptor(logger::Logger &logger);
 
     ~SanitizerInterceptor();
 
@@ -261,6 +261,7 @@ class SanitizerInterceptor {
     ur_shared_mutex m_AllocationMapMutex;
 
     std::unique_ptr<Quarantine> m_Quarantine;
+    logger::Logger &logger;
 };
 
 } // namespace ur_sanitizer_layer

source/loader/layers/sanitizer/asan_options.hpp

@@ -27,8 +27,8 @@ struct AsanOptions {
     AsanOptions(AsanOptions &other) = delete;
     void operator=(const AsanOptions &) = delete;
 
-    static AsanOptions &getInstance() {
-        static AsanOptions instance;
+    static AsanOptions &getInstance(logger::Logger &logger) {
+        static AsanOptions instance(logger);
         return instance;
     }
 
@@ -40,7 +40,7 @@ struct AsanOptions {
     bool DetectPrivates = true;
 
   private:
-    AsanOptions() {
+    AsanOptions(logger::Logger &logger) {
         auto OptionsEnvMap = getenv_to_map("UR_LAYER_ASAN_OPTIONS");
         if (!OptionsEnvMap.has_value()) {
             return;
@@ -117,9 +117,8 @@ struct AsanOptions {
                 MinRZSize = std::stoul(Value);
                 if (MinRZSize < 16) {
                     MinRZSize = 16;
-                    getContext()->logger.warning(
-                        "Trying to set redzone size to a "
-                        "value less than 16 is ignored");
+                    logger.warning("Trying to set redzone size to a "
+                                   "value less than 16 is ignored");
                 }
             } catch (...) {
                 die("<SANITIZER>[ERROR]: \"redzone\" should be an integer");
@@ -133,9 +132,8 @@ struct AsanOptions {
                 MaxRZSize = std::stoul(Value);
                 if (MaxRZSize > 2048) {
                     MaxRZSize = 2048;
-                    getContext()->logger.warning(
-                        "Trying to set max redzone size to a "
-                        "value greater than 2048 is ignored");
+                    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");
@@ -144,6 +142,8 @@ struct AsanOptions {
     }
 };
 
-inline const AsanOptions &Options() { return AsanOptions::getInstance(); }
+inline const AsanOptions &Options(logger::Logger &logger) {
+    return AsanOptions::getInstance(logger);
+}
 
 } // namespace ur_sanitizer_layer

source/loader/layers/sanitizer/asan_report.cpp

@@ -124,7 +124,7 @@ void ReportUseAfterFree(const DeviceSanitizerReport &Report,
     getContext()->logger.always("  #0 {} {}:{}", Func, File, Report.Line);
     getContext()->logger.always("");
 
-    if (Options().MaxQuarantineSizeMB > 0) {
+    if (Options(getContext()->logger).MaxQuarantineSizeMB > 0) {
         auto AllocInfoItOp =
             getContext()->interceptor->findAllocInfoByAddress(Report.Address);
 

source/loader/layers/sanitizer/ur_sanitizer_layer.cpp

@@ -20,7 +20,7 @@ context_t *getContext() { return context_t::get_direct(); }
 context_t::context_t()
     : logger(logger::create_logger("sanitizer", false, false,
                                    logger::Level::WARN)),
-      interceptor(std::make_unique<SanitizerInterceptor>()) {}
+      interceptor(std::make_unique<SanitizerInterceptor>(logger)) {}
 
 ur_result_t context_t::tearDown() { return UR_RESULT_SUCCESS; }