[UR] Refactor validation layer refcount feature

The leak checking feature has been expanded to include handles
obtained via the ...Get() functions.

Author: kswiecicki

scripts/templates/helper.py

@@ -1486,45 +1486,79 @@ def get_loader_epilogue(specs, namespace, tags, obj, meta):
 
     return epilogue
 
+
+def get_event_wait_list_functions(specs, namespace, tags):
+    funcs = []
+    for s in specs:
+        for obj in s['objects']:
+            if re.match(r"function", obj['type']):
+                if any(x['name'] == 'phEventWaitList' for x in obj['params']) and any(
+                        x['name'] == 'numEventsInWaitList' for x in obj['params']):
+                    funcs.append(make_func_name(namespace, tags, obj))
+    return funcs
+
+
 """
-Public:
-    returns a dictionary with lists of create, retain and release functions
+Private:
+    returns a dictionary with lists of create, get, retain and release functions
 """
-def get_create_retain_release_functions(specs, namespace, tags):
+def _get_create_get_retain_release_functions(specs, namespace, tags):
     funcs = []
     for s in specs:
         for obj in s['objects']:
             if re.match(r"function", obj['type']):
                 funcs.append(make_func_name(namespace, tags, obj))
 
-    create_suffixes = r"(Create[A-Za-z]*){1}"
-    retain_suffixes = r"(Retain){1}"
-    release_suffixes = r"(Release){1}"
+    create_suffixes = r"(Create[A-Za-z]*){1}$"
+    get_suffixes = r"(Get){1}$"
+    retain_suffixes = r"(Retain){1}$"
+    release_suffixes = r"(Release){1}$"
+    common_prefix = r"^" + namespace
 
-    create_exp = namespace + r"([A-Za-z]+)" + create_suffixes
-    retain_exp = namespace + r"([A-Za-z]+)" + retain_suffixes
-    release_exp = namespace + r"([A-Za-z]+)" + release_suffixes
+    create_exp = common_prefix + r"[A-Za-z]+" + create_suffixes
+    get_exp = common_prefix + r"[A-Za-z]+" + get_suffixes
+    retain_exp = common_prefix + r"[A-Za-z]+" + retain_suffixes
+    release_exp = common_prefix + r"[A-Za-z]+" + release_suffixes
 
-    create_funcs, retain_funcs, release_funcs = (
+    create_funcs, get_funcs, retain_funcs, release_funcs = (
         list(filter(lambda f: re.match(create_exp, f), funcs)),
+        list(filter(lambda f: re.match(get_exp, f), funcs)),
         list(filter(lambda f: re.match(retain_exp, f), funcs)),
         list(filter(lambda f: re.match(release_exp, f), funcs)),
     )
 
-    create_funcs, retain_funcs = (
-        list(filter(lambda f: re.sub(create_suffixes, "Release", f) in release_funcs, create_funcs)),
-        list(filter(lambda f: re.sub(retain_suffixes, "Release", f) in release_funcs, retain_funcs)),
-    )
+    return {"create": create_funcs, "get": get_funcs, "retain": retain_funcs, "release": release_funcs}
 
-    return {"create": create_funcs, "retain": retain_funcs, "release": release_funcs}
 
+"""
+Public:
+    returns a list of dictionaries containing handle types and the corresponding create, get, retain and release functions
+"""
+def get_handle_create_get_retain_release_functions(specs, namespace, tags):
+    # Handles without release function
+    excluded_handles = ["$x_platform_handle_t", "$x_native_handle_t"]
+    # Handles from experimental features
+    exp_prefix = "$x_exp"
+
+    funcs = _get_create_get_retain_release_functions(specs, namespace, tags)
+    records = []
+    for h in get_adapter_handles(specs):
+        if h['name'] in excluded_handles or h['name'].startswith(exp_prefix):
+            continue
 
-def get_event_wait_list_functions(specs, namespace, tags):
-    funcs = []
-    for s in specs:
-        for obj in s['objects']:
-            if re.match(r"function", obj['type']):
-                if any(x['name'] == 'phEventWaitList' for x in obj['params']) and any(
-                        x['name'] == 'numEventsInWaitList' for x in obj['params']):
-                    funcs.append(make_func_name(namespace, tags, obj))
-    return funcs
+        class_type = subt(namespace, tags, h['class'])
+        create_funcs = list(filter(lambda f: class_type in f, funcs['create']))
+        get_funcs = list(filter(lambda f: class_type in f, funcs['get']))
+        retain_funcs = list(filter(lambda f: class_type in f, funcs['retain']))
+        release_funcs = list(filter(lambda f: class_type in f, funcs['release']))
+
+        record = {}
+        record['handle'] = subt(namespace, tags, h['name'])
+        record['create'] = create_funcs
+        record['get'] = get_funcs
+        record['retain'] = retain_funcs
+        record['release'] = release_funcs
+
+        records.append(record)
+
+    return records

scripts/templates/valddi.cpp.mako

@@ -7,7 +7,8 @@ from templates import helper as th
 
     x=tags['$x']
     X=x.upper()
-    create_retain_release_funcs=th.get_create_retain_release_functions(specs, n, tags)
+
+    handle_create_get_retain_release_funcs=th.get_handle_create_get_retain_release_functions(specs, n, tags)
 %>/*
  *
  * Copyright (C) 2023 Intel Corporation
@@ -27,11 +28,12 @@ namespace ur_validation_layer
     %for obj in th.get_adapter_functions(specs):
     <%
         func_name=th.make_func_name(n, tags, obj)
-        object_param=th.make_param_lines(n, tags, obj, format=["name"])[-1]
-        object_param_type=th.make_param_lines(n, tags, obj, format=["type"])[-1]
+
         param_checks=th.make_param_checks(n, tags, obj, meta=meta).items()
         first_errors = [X + "_RESULT_ERROR_INVALID_NULL_POINTER", X + "_RESULT_ERROR_INVALID_NULL_HANDLE"]
         sorted_param_checks = sorted(param_checks, key=lambda pair: False if pair[0] in first_errors else True)
+
+        tracked_params = list(filter(lambda p: any(th.subt(n, tags, p['type']) in [hf['handle'], hf['handle'] + "*"] for hf in handle_create_get_retain_release_funcs), obj['params']))
     %>
     ///////////////////////////////////////////////////////////////////////////////
     /// @brief Intercept function for ${th.make_func_name(n, tags, obj)}
@@ -74,37 +76,35 @@ namespace ur_validation_layer
 
         ${x}_result_t result = ${th.make_pfn_name(n, tags, obj)}( ${", ".join(th.make_param_lines(n, tags, obj, format=["name"]))} );
 
-        %if func_name == n + "AdapterRelease":
-        if( context.enableLeakChecking && result == UR_RESULT_SUCCESS )
-        {
-            refCountContext.decrementRefCount(${object_param}, true);
-        }
-        %elif func_name == n + "AdapterRetain":
+        %for tp in tracked_params:
+        <%
+            tp_handle_funcs = next((hf for hf in handle_create_get_retain_release_funcs if th.subt(n, tags, tp['type']) in [hf['handle'], hf['handle'] + "*"]), None)
+            is_handle_to_adapter = ("_adapter_handle_t" in tp['type'])
+        %>
+        %if func_name in tp_handle_funcs['create']:
         if( context.enableLeakChecking && result == UR_RESULT_SUCCESS )
         {
-            refCountContext.incrementRefCount(${object_param}, true);
+            refCountContext.createRefCount(*${tp['name']});
         }
-        %elif func_name == n + "AdapterGet":
-        if( context.enableLeakChecking && phAdapters && result == UR_RESULT_SUCCESS )
+        %elif func_name in tp_handle_funcs['get']:
+        if( context.enableLeakChecking && ${tp['name']} && result == UR_RESULT_SUCCESS )
         {
-            refCountContext.createOrIncrementRefCount(*phAdapters, true);
-        }
-        %elif func_name in create_retain_release_funcs["create"]:
-        if( context.enableLeakChecking && result == UR_RESULT_SUCCESS )
-        {
-            refCountContext.createRefCount(*${object_param});
+            for (uint32_t i = ${th.param_traits.range_start(tp)}; i < ${th.param_traits.range_end(tp)}; i++) {
+                refCountContext.createOrIncrementRefCount(${tp['name']}[i], ${str(is_handle_to_adapter).lower()});
+            }
         }
-        %elif func_name in create_retain_release_funcs["retain"]:
+        %elif func_name in tp_handle_funcs['retain']:
         if( context.enableLeakChecking && result == UR_RESULT_SUCCESS )
         {
-            refCountContext.incrementRefCount(${object_param});
+            refCountContext.incrementRefCount(${tp['name']}, ${str(is_handle_to_adapter).lower()});
         }
-        %elif func_name in create_retain_release_funcs["release"]:
+        %elif func_name in tp_handle_funcs['release']:
         if( context.enableLeakChecking && result == UR_RESULT_SUCCESS )
         {
-            refCountContext.decrementRefCount(${object_param});
+            refCountContext.decrementRefCount(${tp['name']}, ${str(is_handle_to_adapter).lower()});
         }
         %endif
+        %endfor
 
         return result;
     }