Add timeout feature

Let the user timeout after a specified number of dynamic instruction
executions. This is very good for testing scripts.

Author: mmoult

src/main.cpp

@@ -231,7 +231,12 @@ int main(int argc, char* argv[]) {
         "r"
     );
     ArgParse::StringOption set_arg("KEY_VAL");
-    parser.addOption(&set_arg, "set", "Define key-value pair in the default format. May be given more than once.", "s");
+    parser.addOption(
+        &set_arg,
+        "set",
+        "Define an input variable via a key-value pair in the default format. May be given more than once.",
+        "s"
+    );
     ArgParse::Flag single_invoc;
     parser.addOption(
         &single_invoc,
@@ -250,6 +255,13 @@ int main(int argc, char* argv[]) {
         "will be printed instead of <type> stubs.",
         "t"
     );
+    ArgParse::UintOption timeout("TEN_EXPONENT", 0);
+    parser.addOption(
+        &timeout,
+        "timeout",
+        "Set a timeout for the shader in terms of 10^x dynamic instruction executions. A value of 0 means no timeout.",
+        "T"
+    );
     ArgParse::Flag unused;
     parser.addOption(
         &unused,
@@ -419,7 +431,7 @@ int main(int argc, char* argv[]) {
 
     // Run the program
     try {
-        program.execute(verbose.enabled, debug.enabled, *format, single_invoc.enabled);
+        program.execute(verbose.enabled, *format, debug.enabled, single_invoc.enabled, timeout.getValue());
     } catch (const std::exception& e) {
         std::cerr << e.what() << std::endl;
         return ReturnCode::FAILED_EXE;

src/spv/program.cpp

@@ -568,7 +568,8 @@ std::tuple<bool, unsigned> Program::checkOutputs(ValueMap& checks) const noexcep
     return std::tuple(outputs.empty(), total_tests);
 }
 
-void Program::execute(bool verbose, bool debug, ValueFormat& format, bool single_invoc) noexcept(false) {
+void Program::execute(bool verbose, ValueFormat& format, bool debug, bool single_invoc, unsigned timeout) noexcept(false
+) {
     Instruction& entry_inst = insts[entry];
     DataView& global = data.getGlobal();
 
@@ -699,10 +700,45 @@ void Program::execute(bool verbose, bool debug, ValueFormat& format, bool single
         new_frame->setPC(pre_pc);
     }
 
+    class Timer {
+        std::vector<uint8_t> tens;
+
+    public:
+        Timer(unsigned power_of_ten) {
+            // 0: off
+            // 1: 10 -> |10|
+            // 2: 100 -> |0|1|
+            // 3: 1000 -> |0|10|
+            // 4: 10000 -> |0|0|1|
+            tens.resize(power_of_ten / 2 + 1, 0);
+            tens.back() = power_of_ten % 2 == 0 ? 1 : 10;
+        }
+
+        bool tick() {
+            bool found = false;
+            unsigned index = 0;
+            for (; index < tens.size(); ++index) {
+                if (tens[index] > 0) {
+                    found = true;
+                    tens[index]--;
+                    break;
+                }
+            }
+            if (!found)
+                return true;
+            for (; index-- > 0;)
+                tens[index] = 99;
+            return false;
+        }
+    } timer(timeout);
+
     // Right now, do something like round robin scheduling. In the future, we will want to give other options
     // through the command line
     unsigned next_invoc = num_invocations - 1;
     while (!live_threads.empty()) {
+        if (timeout > 0 && timer.tick())
+            throw std::runtime_error("Execution timed out!");
+
         if (active_threads.empty()) {
             // All active threads have hit a barrier. Unblock all.
             for (unsigned live : live_threads)

src/spv/program.hpp

@@ -119,7 +119,13 @@ class Program {
 
     std::tuple<bool, unsigned> checkOutputs(ValueMap& checks) const noexcept(true);
 
-    void execute(bool verbose, bool debug, ValueFormat& format, bool single_invoc) noexcept(false);
+    /// @brief Executes the program with the current data and entry point
+    /// @param verbose display: whether to print extra info during execution, such as instructions executed and results
+    /// @param format display: the format in which to print output variables if verbose is enabled
+    /// @param debug debug: whether to invoke the debugger
+    /// @param single_invoc debug: whether to run only a single invocation, ignoring others in the workgroup
+    /// @param timeout debug: the maximum number of instructions to execute before timing out
+    void execute(bool verbose, ValueFormat& format, bool debug, bool single_invoc, unsigned timeout) noexcept(false);
 
     ValueMap getVariables(const std::vector<unsigned>& vars, bool prefer_location) const;
 

test/example-runner.py

@@ -65,7 +65,8 @@ def check_file(root, out_file, stdout):
 
         if program is not None:
             for num, files in configs.items():
-                cmd = [interp_path, program]
+                # A timeout of 5 is 100,000 dynamic instruction executions
+                cmd = [interp_path, program, "-T", "5"]
                 output = False
                 out_file = None
 

usage-help.md

@@ -70,3 +70,17 @@ This section is in development. Come back later.
 ## Program Control
 
 This section is in development. Come back later.
+
+### Timeout
+SPIR-V programs may contain infinite loops, especially for unintended inputs. When invoking the interpreter, it may be
+undesirable for the execution to extend beyond an anticipated runtime. This is often the case when running testing
+scripts- an infinite loop would prevent the execution from being calculated into the final result.
+
+Using the `-T` or `--timeout` option, the user may specify a fixed number of dynamic instruction executions for the
+program not to exceed, given as a power of 10. For example, 1 is 10^1 = 10 instructions, 2 is 10^2 = 100 instructions,
+and so on.
+
+A dynamic instruction execution is a single instance on a single thread. Therefore, if the same instruction is repeated
+several times in a program, it will be counted multiple times for the dynamic instruction count. If multiple threads run
+an instruction, the instruction will be counted for each thread.
+