resolved merge conflicts

Author: myrepo1

backends/ze/tracer_ze_helpers.include.c

@@ -1323,6 +1323,71 @@ static void _dump_driver_device_properties(ze_driver_handle_t hDriver) {
   }
 }
 
+/* Emit a device_peer_access tracepoint for every ordered (src, peer) pair
+ * across a driver's devices and their sub-devices. A device is never paired
+ * with itself, but sub-devices of the same parent are paired with each other
+ * and with other parents' sub-devices. */
+static void _dump_driver_p2p(ze_driver_handle_t hDriver) {
+  if (!tracepoint_enabled(lttng_ust_ze_properties, zeMetadata_device_peer_access))
+    return;
+
+  uint32_t deviceCount = 0;
+  if (ZE_DEVICE_GET_PTR(hDriver, &deviceCount, NULL) != ZE_RESULT_SUCCESS || deviceCount == 0)
+    return;
+  ze_device_handle_t *phDevices =
+      (ze_device_handle_t *)alloca(deviceCount * sizeof(ze_device_handle_t));
+  if (ZE_DEVICE_GET_PTR(hDriver, &deviceCount, phDevices) != ZE_RESULT_SUCCESS)
+    return;
+
+  /* First pass: count the flat total (devices + all sub-devices) so we can
+   * allocate a single flat handle array. */
+  uint32_t totalCount = deviceCount;
+  for (uint32_t i = 0; i < deviceCount; i++) {
+    uint32_t subCount = 0;
+    if (ZE_DEVICE_GET_SUB_DEVICES_PTR(phDevices[i], &subCount, NULL) == ZE_RESULT_SUCCESS)
+      totalCount += subCount;
+  }
+
+  ze_device_handle_t *phAll =
+      (ze_device_handle_t *)alloca(totalCount * sizeof(ze_device_handle_t));
+  uint32_t idx = 0;
+  for (uint32_t i = 0; i < deviceCount; i++) {
+    phAll[idx++] = phDevices[i];
+    uint32_t subCount = 0;
+    if (ZE_DEVICE_GET_SUB_DEVICES_PTR(phDevices[i], &subCount, NULL) != ZE_RESULT_SUCCESS ||
+        subCount == 0)
+      continue;
+    if (ZE_DEVICE_GET_SUB_DEVICES_PTR(phDevices[i], &subCount, phAll + idx) != ZE_RESULT_SUCCESS)
+      continue;
+    idx += subCount;
+  }
+  totalCount = idx;
+
+  for (uint32_t i = 0; i < totalCount; i++) {
+    for (uint32_t j = 0; j < totalCount; j++) {
+      if (i == j)
+        continue;
+      ze_bool_t canAccess = 0;
+      if (ZE_DEVICE_CAN_ACCESS_PEER_PTR(phAll[i], phAll[j], &canAccess) != ZE_RESULT_SUCCESS)
+        continue;
+      ze_device_p2p_properties_t props = {0};
+      props.stype = ZE_STRUCTURE_TYPE_DEVICE_P2P_PROPERTIES;
+      props.pNext = NULL;
+      if (ZE_DEVICE_GET_P2PPROPERTIES_PTR(phAll[i], phAll[j], &props) != ZE_RESULT_SUCCESS)
+        continue;
+      do_tracepoint(lttng_ust_ze_properties, zeMetadata_device_peer_access, hDriver, phAll[i], phAll[j],
+                    canAccess, &props);
+    }
+  }
+}
+
+static void _dump_p2p_all_drivers(uint32_t driverCount, ze_driver_handle_t *phDrivers) {
+  if (!tracepoint_enabled(lttng_ust_ze_properties, zeMetadata_device_peer_access))
+    return;
+  for (uint32_t i = 0; i < driverCount; i++)
+    _dump_driver_p2p(phDrivers[i]);
+}
+
 static void _dump_kernel_properties(ze_kernel_handle_t hKernel) {
   ze_kernel_properties_t kernelProperties = {.stype = ZE_STRUCTURE_TYPE_KERNEL_PROPERTIES};
   if (ZE_KERNEL_GET_PROPERTIES_PTR(hKernel, &kernelProperties) == ZE_RESULT_SUCCESS)

backends/ze/ze_events.yaml

@@ -171,6 +171,19 @@ lttng_ust_ze_properties:
     - [ctf_integer_hex, uintptr_t, hDevice, "(uintptr_t)hDevice"]
     - [ctf_integer, uint32_t, numGroups, numGroups]
     - [ctf_sequence_text, uint8_t, pGroupProperties_val, pGroupProperties, size_t, "numGroups * sizeof(ze_command_queue_group_properties_t)"]
+  - name: zeMetadata_device_peer_access
+    args:
+    - [ze_driver_handle_t, hDriver]
+    - [ze_device_handle_t, hDevice]
+    - [ze_device_handle_t, hPeerDevice]
+    - [ze_bool_t, canAccess]
+    - [ze_device_p2p_properties_t *, pP2PProperties]
+    fields:
+    - [ctf_integer_hex, uintptr_t, hDriver, "(uintptr_t)hDriver"]
+    - [ctf_integer_hex, uintptr_t, hDevice, "(uintptr_t)hDevice"]
+    - [ctf_integer_hex, uintptr_t, hPeerDevice, "(uintptr_t)hPeerDevice"]
+    - [ctf_integer, uint8_t, canAccess, canAccess]
+    - [ctf_sequence_text, uint8_t, pP2PProperties_val, pP2PProperties, size_t, "sizeof(ze_device_p2p_properties_t)"]
   - name: device_timer
     args:
     - [ze_device_handle_t, hDevice]

backends/ze/ze_model.rb

@@ -10,7 +10,7 @@
 
 RESULT_NAME = 'zeResult'
 
-$ze_api_yaml = YAML.load_file('ze_api.yaml')
+$ze_api_yaml = YAML.load_file('ze_api.yaml') # $var represents global var. @var Instance var, @@var class var, var local var, VAR constant
 $zet_api_yaml = YAML.load_file('zet_api.yaml')
 $zes_api_yaml = YAML.load_file('zes_api.yaml')
 $zel_api_yaml = YAML.load_file('zel_api.yaml')
@@ -35,15 +35,15 @@
 typedefs = $ze_api['typedefs'] + $zet_api['typedefs'] + $zes_api['typedefs'] + $zel_api['typedefs'] + $zer_api['typedefs'] + $zex_api['typedefs']
 structs = $ze_api['structs'] + $zet_api['structs'] + $zes_api['structs'] + $zel_api['structs'] + $zer_api['structs'] + $zex_api['structs']
 
-find_all_types(typedefs)
+find_all_types(typedefs) #yaml_ast.rb
 gen_struct_map(typedefs, structs)
 gen_ffi_type_map(typedefs)
 
 # zesInit is included here so that a pure-Sysman program (one that only calls
 # zesInit, never zeInit) still triggers the tracer initialization.
 # Ideally we would split this into INIT_ZE_FUNCTIONS / INIT_ZES_FUNCTIONS
 # so each namespace initializes its own symbols.
-INIT_FUNCTIONS = /zeInit|zeLoaderInit|zeInitDrivers|zesInit/
+INIT_FUNCTIONS = /zeInit|zeLoaderInit|zeInitDrivers|zesInit/ # REGEX
 
 $struct_type_conversion_table = {
   'ZE_STRUCTURE_TYPE_IMAGE_MEMORY_PROPERTIES_EXP' => 'ZE_STRUCTURE_TYPE_IMAGE_MEMORY_EXP_PROPERTIES',
@@ -274,11 +274,23 @@ def upper_snake_case(str)
     _on_destroy_event(hEvent);
 EOF
 
+# Emit device_peer_access tracepoints after the loader hands back the driver
+# list. Guarded on phDrivers so the count-only invocation (phDrivers == NULL)
+# doesn't trigger a dump.
+p2p_epilogue = <<EOF
+  if (_retval == ZE_RESULT_SUCCESS && phDrivers && pCount &&
+      tracepoint_enabled(lttng_ust_ze_properties, zeMetadata_device_peer_access)) {
+    _dump_p2p_all_drivers(*pCount, phDrivers);
+  }
+EOF
+register_epilogue 'zeDriverGet',   p2p_epilogue
+register_epilogue 'zeInitDrivers', p2p_epilogue
+
 # Dump memory info if required
 memory_info_dump = lambda { |ptr_name|
   "_dump_memory_info(hCommandList, #{ptr_name})"
 }
-
+#memory info device,heap, etc. Only if paranoid memory tracking is enabled
 memory_info_prologue = lambda { |ptr_names|
   <<EOF
   if (_do_paranoid_memory_location &&
@@ -346,6 +358,7 @@ def upper_snake_case(str)
 EOF
 }
 
+# event name is known from API Spec
 profiling_epilogue = lambda { |_event_name, waits_expr = 'phWaitEvents', n_waits_expr = 'numWaitEvents'|
   <<EOF
   if (_do_profile && _einj) {
@@ -449,6 +462,8 @@ def upper_snake_case(str)
  }
 EOF
 
+# generates the dispatch table?
+# replaces the original function calls with the wrappers
 ($ze_commands + $zet_commands + $zes_commands + $zel_commands + $zer_commands).select do |c|
   c.name.match(/(ze|zet|zes|zel|zer)Get.*ProcAddrTable/)
 end.each do |c|
@@ -576,4 +591,4 @@ def get_ffi_type(a)
 
 register_epilogue 'zeInit', <<EOF
   _in_loader_init = 0;
-EOF
+EOF

utils/command.rb

@@ -134,3 +134,5 @@ def register_epilogue(method, code)
 META_PARAMETERS = Hash.new { |h, k| h[k] = [] }
 PROLOGUES = Hash.new { |h, k| h[k] = [] }
 EPILOGUES = Hash.new { |h, k| h[k] = [] }
+
+# appending of prologues and epilogues happens later