Make it possible to cancel a simulation

Author: anderspkd

include/scl/simulation/cancellation.h

@@ -0,0 +1,32 @@
+/* SCL --- Secure Computation Library
+ * Copyright (C) 2025 Anders Dalskov
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdexcept>
+namespace scl {
+namespace details {
+
+struct CancellationException final : public std::runtime_error {
+  CancellationException() : std::runtime_error("cancelled") {}
+};
+
+}  // namespace details
+
+inline void forceStopProtocol() {
+  throw details::CancellationException{};
+}
+
+}  // namespace scl

src/scl/simulation/simulator.cc

@@ -22,6 +22,7 @@
 
 #include "scl/net/loopback.h"
 #include "scl/protocol.h"
+#include "scl/simulation/cancellation.h"
 #include "scl/simulation/channel.h"
 #include "scl/simulation/context.h"
 #include "scl/simulation/event.h"
@@ -111,29 +112,25 @@ Task<void> runProtocol(std::unique_ptr<Protocol> protocol,
       ctx.addEvent<EndEvent>(et, protocol->name());
 
       if (next.output.has_value()) {
+        ctx.addEvent<OutputEvent>(et);
         ctx.output(next.output);
       }
 
-      // This will suspend this party, allowing someone else to run. It's not
-      // really needed, but (hopefully) it ensures a more "fair" execution
-      // order.
-      //
-      // TODO: Is this needed?
-      co_await []() { return true; };
-
       protocol = std::move(next.next);
     }
 
     ctx.addEvent<StopEvent>(ctx.lastEvent()->time());
 
-  } catch (CancelledEvent&) {
+  } catch (details::CancellationException& /* ignored */) {
     // this party was stopped by a user supplied hook.
     ctx.addEvent<CancelledEvent>(ctx.lastEvent()->time());
+    co_return;
 
   } catch (std::exception& e) {
     // all exceptions are caught and discarded, but we make sure to record an
     // event.
     ctx.addEvent<KilledEvent>(ctx.lastEvent()->time(), e.what());
+    co_return;
   }
 }
 

test/scl/simulation/test_simulator.cc

@@ -17,11 +17,12 @@
 
 #include <any>
 #include <catch2/catch_test_macros.hpp>
-#include <initializer_list>
+#include <iostream>
 #include <memory>
 
 #include "scl/coro.h"
 #include "scl/protocol.h"
+#include "scl/simulation/cancellation.h"
 #include "scl/simulation/event.h"
 #include "scl/simulation/params.h"
 #include "scl/simulation/simulator.h"
@@ -103,7 +104,7 @@ TEST_CASE("Simulator test", "[sim]") {
 
 namespace {
 
-struct OutputProtocol final : public Protocol {
+struct SimpleProtocol final : public Protocol {
   Task<Result> run(Env& /* ignored */) const override {
     co_return Result::done(123);
   }
@@ -125,10 +126,89 @@ TEST_CASE("Simulator handle output", "[sim]") {
   auto res = sim.run(
       []() {
         std::vector<std::unique_ptr<Protocol>> p;
-        p.emplace_back(std::make_unique<OutputProtocol>());
+        p.emplace_back(std::make_unique<SimpleProtocol>());
         return p;
       },
       nd);
 
   REQUIRE(called);
 }
+
+TEST_CASE("Simulator hooks no trigger", "[sim]") {
+  auto nd = NetworkParams::create(1);
+
+  std::size_t num_called = 0;
+
+  Simulator sim;
+  sim.addHook([&num_called](std::size_t /* ignored*/, Event* /* ignored*/) {
+    num_called++;
+  });
+
+  auto res = sim.run(
+      []() {
+        std::vector<std::unique_ptr<Protocol>> p;
+        p.emplace_back(std::make_unique<SimpleProtocol>());
+        return p;
+      },
+      nd);
+
+  REQUIRE(num_called == res[0].size());
+}
+
+TEST_CASE("Simulator hooks with trigger", "[sim]") {
+  auto nd = NetworkParams::create(1);
+
+  bool start_hook_called = false;
+  bool send_hook_called = false;
+
+  Simulator sim;
+
+  // should be called
+  sim.addHook(EventType::START,
+              [&start_hook_called](std::size_t pid, Event* evt) {
+                start_hook_called =
+                    (pid == 0) && (evt->type() == EventType::START);
+              });
+
+  // should not be called
+  sim.addHook(
+      EventType::CHANNEL_SEND,
+      [&send_hook_called](std::size_t /* ignored*/, Event* /* ignored*/) {
+        send_hook_called = true;
+      });
+
+  auto res = sim.run(
+      []() {
+        std::vector<std::unique_ptr<Protocol>> p;
+        p.emplace_back(std::make_unique<SimpleProtocol>());
+        return p;
+      },
+      nd);
+
+  REQUIRE(start_hook_called);
+  REQUIRE_FALSE(send_hook_called);
+}
+
+TEST_CASE("Simulator cancellation", "[sim]") {
+  auto nd = NetworkParams::create(2);
+
+  Simulator sim;
+
+  sim.addHook(EventType::START,
+              [](std::size_t /* ignored */, Event* /* ignored */) {
+                forceStopProtocol();
+              });
+
+  auto res = sim.run(
+      []() {
+        std::vector<std::unique_ptr<Protocol>> p;
+        p.emplace_back(std::make_unique<SimpleProtocol>());
+        p.emplace_back(std::make_unique<SimpleProtocol>());
+        return p;
+      },
+      nd);
+
+  REQUIRE(res.numberOfParties() == 2);
+
+  assertEvents(res[0], {EventType::START, EventType::CANCELLED});
+}