reset support for command list. Not part of the paper atm

Author: myrepo1

backends/ze/ze_validator_entry_exit_helpers.rb

@@ -286,6 +286,50 @@ def check_command_list_closed(state, ctx, defi)
 end
 
 
+# ADDED: validate a zeCommandListReset. Runs at ENTRY, before the model applies
+# the reset, reading the list handle from defi. Reports three misuses:
+#   * already-destroyed list -- resetting a destroyed handle is a usage error.
+#   * immediate command list -- zeCommandListReset is invalid on an immediate list
+#     (it has no closed/execute lifecycle to reset); the runtime returns
+#     ZE_RESULT_ERROR_INVALID_ARGUMENT.
+#   * reset while in-flight -- the list is still executing a prior
+#     zeCommandQueueExecuteCommandLists submission. Resetting it now races the
+#     device and is undefined behavior in Level Zero.
+# Every command list handle is tracked, so the list is always found.
+# Reported once per (command list, reason) pair.
+def check_command_list_reset(state, ctx, defi)
+  handle = defi['hCommandList']
+  cmd_list = state.find_objects(ctx, 'command_list')[handle]
+
+  if cmd_list.status == ZEModel::CommandList.class_variable_get(:@@DESTROYED)
+    key = "clreset-destroyed-#{state.get_handle_str(handle)}"
+    if state.print_tracker[key] == 0
+      state.print_tracker[key] = 1
+      state.print_usage_error(ctx, "command list #{state.get_handle_str(handle)} was already destroyed before zeCommandListReset")
+    end
+    return
+  end
+
+  if cmd_list.immediate
+    key = "clreset-immediate-#{state.get_handle_str(handle)}"
+    if state.print_tracker[key] == 0
+      state.print_tracker[key] = 1
+      state.print_usage_error(ctx, "zeCommandListReset called on immediate command list #{state.get_handle_str(handle)}; " \
+                                   "immediate command lists cannot be reset")
+    end
+  end
+
+  if state.command_list_in_flight?(ctx, handle)
+    key = "clreset-inflight-#{state.get_handle_str(handle)}"
+    if state.print_tracker[key] == 0
+      state.print_tracker[key] = 1
+      state.print_usage_error(ctx, "command list #{state.get_handle_str(handle)} is being reset while a prior " \
+                                   "zeCommandQueueExecuteCommandLists submission is still in-flight; the device may " \
+                                   "still be executing it (undefined behavior)")
+    end
+  end
+end
+
 def check_valid_module(state,ctx,defi)
   module_handle = state.find_param(ctx, 'hModule')
   if !module_handle || module_handle == 0

backends/ze/ze_validator_function_entry_exit_callbacks.rb

@@ -73,6 +73,27 @@
               api: 'zeCommandListAppendLaunchKernel'))
 }
 
+# ADDED: zeCommandListReset returns a command list to its initial, empty,
+# appendable state so it can be reused without destroy+recreate. Misuse checks run
+# at ENTRY (a reset can be rejected/crash without emitting an _exit -- e.g. on an
+# immediate list) reading the input handle from defi.
+$upon_entry["zeCommandListReset"] = lambda { |state, ctx, defi|
+  check_command_list_reset(state, ctx, defi)
+}
+
+# ADDED: on success the list is empty and open again. Clear the recorded ops so a
+# later close/execute replays only ops appended after the reset (in-flight
+# executions from before are unaffected -- enqueue_deferred_execution snapshotted
+# a dup of the ops at submit time), and return the status to INITIALIZED so the
+# closed-before-execute check applies to the reused list.
+$on_successful_exit["zeCommandListReset"] = lambda { |state, ctx, defi|
+  command_lists = state.find_objects(ctx, 'command_list')
+  cmd_list = command_lists[state.find_param(ctx, 'hCommandList')]
+  return unless cmd_list
+  cmd_list.ops.clear
+  cmd_list.status = ZEModel::CommandList.class_variable_get(:@@INITIALIZED)
+}
+
 #when command queue is executed, the associated fence's status is set to IN_USE
 $on_successful_exit["zeCommandListClose"] = lambda { |state, ctx, defi|
   command_lists = state.find_objects(ctx, 'command_list')

backends/ze/ze_validator_state_object.rb

@@ -275,6 +275,22 @@ def each_inflight_copy_op(context)
     end
   end
 
+  # ADDED: true if command list `handle` still has an in-flight deferred
+  # execution in this process -- a prior zeCommandQueueExecuteCommandLists whose
+  # ops have not all drained yet. Used by zeCommandListReset, which must not run
+  # while the list is still executing (undefined behavior in Level Zero). Matches
+  # on the unit's originating list handle and the process it belongs to (deferred
+  # units carry no pid, so we compare context host+pid, mirroring
+  # each_inflight_copy_op).
+  def command_list_in_flight?(context, handle)
+    @deferred_units.any? do |unit|
+      unit.cmd_list_handle == handle &&
+        unit.context['hostname'] == context['hostname'] &&
+        unit.context['vpid'] == context['vpid'] &&
+        !unit.done?
+    end
+  end
+
   def to_struct(memory, klass)
     memory.size > 0 ? klass.new(FFI::MemoryPointer.from_string(memory)) : nil
   end
@@ -402,8 +418,9 @@ def pump_deferred
   # ADDED: register a command list's ops as a deferred unit and pump. `ops` is a
   # snapshot (dup) taken by the caller so a later reset+re-append on the same
   # list cannot mutate an in-flight execution.
-  def run_deferred_list(context, ops, label, in_order: false)
-    @deferred_units << ZEModel::DeferredUnit.new(ops, context, label, in_order: in_order)
+  def run_deferred_list(context, ops, label, in_order: false, cmd_list_handle: nil)
+    @deferred_units << ZEModel::DeferredUnit.new(ops, context, label, in_order: in_order,
+                                                 cmd_list_handle: cmd_list_handle)
     pump_deferred
   end
 
@@ -416,7 +433,7 @@ def enqueue_deferred_execution(context, command_lists)
     command_lists.each do |cl|
       next unless cl
       run_deferred_list(context, cl.ops.dup, "command_list (#{get_handle_str(cl.handle)})",
-                        in_order: cl.in_order)
+                        in_order: cl.in_order, cmd_list_handle: cl.handle)
     end
   end
 

backends/ze/ze_validator_zemodel.rb

@@ -360,14 +360,20 @@ class DeferredUnit
     # ADDED: whether the originating command list is in-order (see CommandList#in_order).
     # The intra-list self-deadlock check only applies to in-order units.
     attr_reader :in_order
+    # ADDED: handle of the command list this unit was submitted from (nil if
+    # unknown/immediate without a handle). Lets checks scoped to a specific list --
+    # e.g. resetting a list while a prior submission is still in-flight -- find the
+    # deferred units that belong to it without matching on the label string.
+    attr_reader :cmd_list_handle
 
-    def initialize(ops, context, label, in_order: false)
+    def initialize(ops, context, label, in_order: false, cmd_list_handle: nil)
       @ops = ops
       @context = context
       @label = label
       @cursor = 0
       @blocked_on = []
       @in_order = in_order # ADDED
+      @cmd_list_handle = cmd_list_handle # ADDED
       #every event this unit will eventually signal, for the wait-for graph
       @pending_signals = ops.map { |op| op.signal }.compact
     end