Merge branch 'main' into num_compute_units

Author: dyniols

.github/workflows/build-hw-reusable.yml

@@ -112,7 +112,7 @@ jobs:
 
     - name: Test adapter specific
       working-directory: ${{github.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} --output-on-failure -L "adapter-specific" --timeout 180
+      run: ctest -C ${{matrix.build_type}} --output-on-failure -L "adapter-specific" -E "memcheck" --timeout 180
       # Don't run adapter specific tests when building multiple adapters
       if: ${{ matrix.adapter.other_name == '' }}
 

cmake/helpers.cmake

@@ -83,7 +83,7 @@ set(CFI_FLAGS "")
 if (CFI_HAS_CFI_SANITIZE)
     # cfi-icall requires called functions in shared libraries to also be built with cfi-icall, which we can't
     # guarantee. -fsanitize=cfi depends on -flto
-    set(CFI_FLAGS "-flto -fsanitize=cfi -fno-sanitize=cfi-icall -fsanitize-ignorelist=${CMAKE_SOURCE_DIR}/sanitizer-ignorelist.txt")
+    set(CFI_FLAGS "-flto -fsanitize=cfi -fno-sanitize=cfi-icall -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/sanitizer-ignorelist.txt")
 endif()
 
 function(add_ur_target_compile_options name)

examples/collector/CMakeLists.txt

@@ -10,7 +10,7 @@ add_ur_library(${TARGET_NAME} SHARED
 )
 
 target_include_directories(${TARGET_NAME} PRIVATE
-    ${CMAKE_SOURCE_DIR}/include
+    ${PROJECT_SOURCE_DIR}/include
 )
 
 target_link_libraries(${TARGET_NAME} PRIVATE ${TARGET_XPTI})

include/ur_api.h

@@ -3555,10 +3555,10 @@ typedef struct ur_usm_pool_limits_desc_t {
 ///         + If ::UR_DEVICE_INFO_USM_HOST_SUPPORT is false.
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///         + `pUSMDesc && pUSMDesc->align != 0 && ((pUSMDesc->align & (pUSMDesc->align-1)) != 0)`
-///         + If `align` is greater that the size of the largest data type supported by `hDevice`.
+///         + If `align` is greater that the size of the largest data type supported by any device in `hContext`.
 ///     - ::UR_RESULT_ERROR_INVALID_USM_SIZE
 ///         + `size == 0`
-///         + `size` is greater than ::UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE.
+///         + `size` is greater than ::UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE for any device in `hContext`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE

scripts/benchmarks/benches/compute.py

@@ -78,8 +78,9 @@ def benchmarks(self) -> list[Benchmark]:
 
         if options.ur is not None:
             benches += [
-                SubmitKernelUR(self, 0),
-                SubmitKernelUR(self, 1),
+                SubmitKernelUR(self, 0, 0),
+                SubmitKernelUR(self, 1, 0),
+                SubmitKernelUR(self, 1, 1),
             ]
 
         return benches
@@ -180,13 +181,14 @@ def bin_args(self) -> list[str]:
         ]
 
 class SubmitKernelUR(ComputeBenchmark):
-    def __init__(self, bench, ioq):
+    def __init__(self, bench, ioq, measureCompletion):
         self.ioq = ioq
+        self.measureCompletion = measureCompletion
         super().__init__(bench, "api_overhead_benchmark_ur", "SubmitKernel")
 
     def name(self):
         order = "in order" if self.ioq else "out of order"
-        return f"api_overhead_benchmark_ur SubmitKernel {order}"
+        return f"api_overhead_benchmark_ur SubmitKernel {order}" + (" with measure completion" if self.measureCompletion else "")
 
     def explicit_group(self):
         return "SubmitKernel"
@@ -195,7 +197,7 @@ def bin_args(self) -> list[str]:
         return [
             f"--Ioq={self.ioq}",
             "--DiscardEvents=0",
-            "--MeasureCompletion=0",
+            f"--MeasureCompletion={self.measureCompletion}",
             "--iterations=100000",
             "--Profiling=0",
             "--NumKernels=10",

scripts/benchmarks/benches/options.py

@@ -26,6 +26,7 @@ class Options:
     # these two should probably be merged into one setting
     stddev_threshold: float = 0.02
     epsilon: float = 0.02
+    iterations_stddev: int = 5
 
 options = Options()
 

scripts/benchmarks/main.py

@@ -160,7 +160,7 @@ def main(directory, additional_env_vars, save_name, compare_names, filter):
             merged_env_vars = {**additional_env_vars}
             intermediate_results: dict[str, list[Result]] = {}
             processed: list[Result] = []
-            for _ in range(5):
+            for _ in range(options.iterations_stddev):
                 run_iterations(benchmark, merged_env_vars, options.iterations, intermediate_results)
                 valid, processed = process_results(intermediate_results, benchmark.stddev_threshold())
                 if valid:
@@ -252,6 +252,12 @@ def validate_and_parse_env_args(env_args):
     parser.add_argument("--output-html", help='Create HTML output', action="store_true", default=False)
     parser.add_argument("--output-markdown", help='Create Markdown output', action="store_true", default=True)
     parser.add_argument("--dry-run", help='Do not run any actual benchmarks', action="store_true", default=False)
+    parser.add_argument(
+    "--iterations-stddev",
+    type=int,
+    help="Max number of iterations of the loop calculating stddev after completed benchmark runs",
+    default=options.iterations_stddev,
+    )
 
     args = parser.parse_args()
     additional_env_vars = validate_and_parse_env_args(args.env)
@@ -272,6 +278,7 @@ def validate_and_parse_env_args(env_args):
     options.output_markdown = args.output_markdown
     options.dry_run = args.dry_run
     options.umf = args.umf
+    options.iterations_stddev = args.iterations_stddev
 
     benchmark_filter = re.compile(args.filter) if args.filter else None
 

scripts/core/usm.yml

@@ -257,10 +257,10 @@ returns:
       - "If $X_DEVICE_INFO_USM_HOST_SUPPORT is false."
     - $X_RESULT_ERROR_INVALID_VALUE:
       - "`pUSMDesc && pUSMDesc->align != 0 && ((pUSMDesc->align & (pUSMDesc->align-1)) != 0)`" # alignment must be power of two
-      - "If `align` is greater that the size of the largest data type supported by `hDevice`."
+      - "If `align` is greater that the size of the largest data type supported by any device in `hContext`."
     - $X_RESULT_ERROR_INVALID_USM_SIZE:
       - "`size == 0`"
-      - "`size` is greater than $X_DEVICE_INFO_MAX_MEM_ALLOC_SIZE."
+      - "`size` is greater than $X_DEVICE_INFO_MAX_MEM_ALLOC_SIZE for any device in `hContext`"
     - $X_RESULT_ERROR_OUT_OF_HOST_MEMORY
     - $X_RESULT_ERROR_OUT_OF_RESOURCES
     - $X_RESULT_ERROR_UNSUPPORTED_FEATURE:

scripts/templates/helper.py

@@ -1130,7 +1130,7 @@ def make_param_checks(namespace, tags, obj, cpp=False, meta=None):
         for key, values in item.items():
             key = subt(namespace, tags, key, False, cpp)
             for val in values:
-                code = re.match(r"^\`(.*)\`$", val)
+                code = re.match(r"^\`([^`]*)\`$", val)
                 if code:
                     if key not in checks:
                         checks[key] = []

scripts/templates/ldrddi.cpp.mako

@@ -24,13 +24,37 @@ from templates import helper as th
 namespace ur_loader
 {
     %for obj in th.get_adapter_functions(specs):
+    <%
+        func_name = th.make_func_name(n, tags, obj)
+        if func_name.startswith(x):
+            func_basename = func_name[len(x):]
+        else:
+            func_basename = func_name
+    %>
+    %if func_basename == "EventSetCallback":
+    namespace {
+    struct event_callback_wrapper_data_t {
+        ${x}_event_callback_t fn;
+        ${x}_event_handle_t event;
+        void *userData;
+    };
+
+    void event_callback_wrapper([[maybe_unused]] ${x}_event_handle_t hEvent,
+                                ${x}_execution_info_t execStatus, void *pUserData) {
+        auto *wrapper =
+            reinterpret_cast<event_callback_wrapper_data_t *>(pUserData);
+        (wrapper->fn)(wrapper->event, execStatus, wrapper->userData);
+        delete wrapper;
+    }
+    }
+
+    %endif
     ///////////////////////////////////////////////////////////////////////////////
-    /// @brief Intercept function for ${th.make_func_name(n, tags, obj)}
+    /// @brief Intercept function for ${func_name}
     %if 'condition' in obj:
     #if ${th.subt(n, tags, obj['condition'])}
     %endif
-    __${x}dlllocal ${x}_result_t ${X}_APICALL
-    ${th.make_func_name(n, tags, obj)}(
+    __${x}dlllocal ${x}_result_t ${X}_APICALL ${func_name}(
         %for line in th.make_param_lines(n, tags, obj):
         ${line}
         %endfor
@@ -41,7 +65,7 @@ namespace ur_loader
     %>${th.get_initial_null_set(obj)}
 
         [[maybe_unused]] auto context = getContext();
-        %if re.match(r"\w+AdapterGet$", th.make_func_name(n, tags, obj)):
+        %if func_basename == "AdapterGet":
 
         size_t adapterIndex = 0;
         if( nullptr != ${obj['params'][1]['name']} && ${obj['params'][0]['name']} !=0)
@@ -74,7 +98,7 @@ namespace ur_loader
             *${obj['params'][2]['name']} = static_cast<uint32_t>(context->platforms.size());
         }
 
-        %elif re.match(r"\w+PlatformGet$", th.make_func_name(n, tags, obj)):
+        %elif func_basename == "PlatformGet":
         uint32_t total_platform_handle_count = 0;
 
         for( uint32_t adapter_index = 0; adapter_index < ${obj['params'][1]['name']}; adapter_index++)
@@ -132,6 +156,16 @@ namespace ur_loader
         <%break%>
         %endif
         %endfor
+        %if func_basename == "EventSetCallback":
+
+        // Replace the callback with a wrapper function that gives the callback the loader event rather than a
+        // backend-specific event
+        auto *wrapper_data =
+            new event_callback_wrapper_data_t{pfnNotify, hEvent, pUserData};
+        pUserData = wrapper_data;
+        pfnNotify = event_callback_wrapper;
+
+        %endif
         %for i, item in enumerate(th.get_loader_prologue(n, tags, obj, meta)):
         %if 'range' in item:
         <%
@@ -263,7 +297,7 @@ namespace ur_loader
         %for i, item in enumerate(epilogue):
         %if 0 == i and not item['release'] and not item['retain'] and not th.always_wrap_outputs(obj):
         ## TODO: Remove once we have a concrete way for submitting warnings in place.
-        %if re.match(r"urEnqueue\w+", th.make_func_name(n, tags, obj)):
+        %if re.match(r"Enqueue\w+", func_basename):
         // In the event of ERROR_ADAPTER_SPECIFIC we should still attempt to wrap any output handles below.
         if( ${X}_RESULT_SUCCESS != result && ${X}_RESULT_ERROR_ADAPTER_SPECIFIC != result )
             return result;