version 5.2.0 (#12)

Author: anderspkd

CMakeLists.txt

@@ -16,7 +16,7 @@
 
 cmake_minimum_required( VERSION 3.14 )
 
-project( scl VERSION 5.1.2 DESCRIPTION "Secure Computation Library" )
+project( scl VERSION 5.2.0 DESCRIPTION "Secure Computation Library" )
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release)

doc/DoxyConf

@@ -15,7 +15,6 @@ INPUT                  = doc/mainpage.md \
 			 include/scl/math/curves \
                          include/scl/ss \
                          include/scl/net \
-                         include/scl/net/discovery \
                          include/scl/simulation \
                          include/scl/protocol
 FILE_PATTERNS          = *.h

include/scl/protocol/base.h

@@ -81,34 +81,46 @@ struct Protocol {
 
 /**
  * @brief Evaluate a protocol.
- * @param protocol the protocol
- * @param network the network to evaluate the protocol with
- * @param output_cb a callback for consuming protocol output
+ * @param protocol the protocol.
+ * @param output_cb a callback for consuming protocol output.
+ * @param env the protocol environment.
  */
 template <typename Callback>
 void Evaluate(std::unique_ptr<Protocol> protocol,
-              net::Network& network,
-              Callback output_cb) {
+              Callback output_cb,
+              Env& env) {
   std::shared_ptr<Protocol> next = std::move(protocol);
   std::shared_ptr<Protocol> prev = next;
 
-  ProtocolEnvironment ctx{network,
-                          std::make_unique<RealTimeClock>(),
-                          std::make_unique<StlThreadContext>()};
-
   while (next != nullptr) {
-    next = next->Run(ctx);
+    next = next->Run(env);
     if (prev->Output().has_value()) {
       output_cb(prev->Output());
     }
     prev = next;
   }
 }
 
+/**
+ * @brief Evaluate a protocol.
+ * @param protocol the protocol.
+ * @param network the network to evaluate the protocol with.
+ * @param output_cb a callback for consuming protocol output.
+ */
+template <typename Callback>
+void Evaluate(std::unique_ptr<Protocol> protocol,
+              net::Network& network,
+              Callback output_cb) {
+  Env ctx{network,
+          std::make_unique<RealTimeClock>(),
+          std::make_unique<StlThreadContext>()};
+  Evaluate(std::move(protocol), output_cb, ctx);
+}
+
 /**
  * @brief Evalate a protocol, discarding all outputs generated.
- * @param protocol the protocol to evaluate
- * @param network the network to use
+ * @param protocol the protocol to evaluate.
+ * @param network the network to use.
  */
 inline void Evaluate(std::unique_ptr<Protocol> protocol,
                      net::Network& network) {

include/scl/protocol/env.h

@@ -35,7 +35,7 @@ namespace scl::proto {
  * number of useful resources, such as a network, but also the ability to know
  * its total running time, as well as the ability to work with threads.
  */
-struct ProtocolEnvironment {
+struct Env {
   /**
    * @brief Interface for the environment's threading context.
    *
@@ -55,6 +55,10 @@ struct ProtocolEnvironment {
 
   /**
    * @brief Interface for the environment's clock context.
+   *
+   * This interface essentially models a "stopwatch" of sorts. The idea is that
+   * it will start ticking when a protocol starts. The protocol can check the
+   * current elapsed time at any point, and mark checkpoints.
    */
   struct Clock {
     virtual ~Clock(){};
@@ -63,6 +67,11 @@ struct ProtocolEnvironment {
      * @brief Read the current value of the clock.
      */
     virtual util::Time::Duration Read() const = 0;
+
+    /**
+     * @brief Record a checkpoint with an associated message.
+     */
+    virtual void Checkpoint(const std::string& message) = 0;
   };
 
   /**
@@ -82,16 +91,32 @@ struct ProtocolEnvironment {
 };
 
 /**
- * @brief A protocol clock which returns the total running time.
+ * @deprecated
+ */
+using ProtocolEnvironment = Env;
+
+/**
+ * @brief A protocol clock which operates with real time.
  */
-class RealTimeClock final : public ProtocolEnvironment::Clock {
+class RealTimeClock final : public Env::Clock {
  public:
-  RealTimeClock() : m_init_time(util::Time::Now()){};
-  ~RealTimeClock(){};
+  RealTimeClock() : m_init_time(util::Time::Now()) {}
+  ~RealTimeClock() {}
 
+  /**
+   * @brief Get the current time.
+   */
   util::Time::Duration Read() const {
     return util::Time::Now() - m_init_time;
-  };
+  }
+
+  /**
+   * @brief Print the current time to stdout.
+   */
+  void Checkpoint(const std::string& message) {
+    auto ms = std::chrono::duration<double, std::milli>(Read()).count();
+    std::cout << message << " @ " << ms << " ms\n";
+  }
 
  private:
   util::Time::TimePoint m_init_time;
@@ -100,16 +125,16 @@ class RealTimeClock final : public ProtocolEnvironment::Clock {
 /**
  * @brief A protocol thread context which uses STL thread.
  */
-class StlThreadContext final : public ProtocolEnvironment::Thread {
+class StlThreadContext final : public Env::Thread {
  public:
-  ~StlThreadContext(){};
+  ~StlThreadContext() {}
 
   /**
    * @brief Sleep the current thread using std::this_thread::sleep_for.
    */
   void Sleep(std::size_t ms) override {
     std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-  };
+  }
 };
 
 }  // namespace scl::proto

include/scl/simulation/env.h

@@ -22,6 +22,7 @@
 
 #include "scl/protocol/env.h"
 #include "scl/simulation/context.h"
+#include "scl/simulation/event.h"
 
 namespace scl::sim {
 
@@ -35,7 +36,7 @@ class SimulatedClock final : public proto::ProtocolEnvironment::Clock {
    * @param ctx a simulation context. Used to read the current time of the party
    * @param id the ID of the party
    */
-  SimulatedClock(const SimulationContext* ctx, std::size_t id)
+  SimulatedClock(std::shared_ptr<SimulationContext> ctx, std::size_t id)
       : m_ctx(ctx), m_id(id){};
 
   /**
@@ -51,8 +52,15 @@ class SimulatedClock final : public proto::ProtocolEnvironment::Clock {
     return now - m_ctx->ReadCurrentCheckpoint() + ts;
   }
 
+  /**
+   * @brief Mark a checkpoint.
+   */
+  void Checkpoint(const std::string& message) override {
+    m_ctx->AddEvent(m_id, std::make_shared<CheckpointEvent>(Read(), message));
+  }
+
  private:
-  const SimulationContext* m_ctx;
+  std::shared_ptr<SimulationContext> m_ctx;
   std::size_t m_id;
 };
 

include/scl/simulation/event.h

@@ -88,7 +88,12 @@ class Event {
     /**
      * @brief Event made at the end of a protocol segment.
      */
-    SEGMENT_END
+    SEGMENT_END,
+
+    /**
+     * @brief A checkpoint recorded by the protocol.
+     */
+    CHECKPOINT
   };
 
   /**
@@ -235,6 +240,31 @@ class SegmentEvent final : public Event {
   std::string m_name;
 };
 
+/**
+ * @brief An event created when a protocol calls
+ * <code>env.clock.Checkpoint()</code>.
+ */
+class CheckpointEvent final : public Event {
+ public:
+  /**
+   * @brief Create a new checkpoint event.
+   * @param timestamp the time of the event.
+   * @param message the message of the checkpoint.
+   */
+  CheckpointEvent(util::Time::Duration timestamp, const std::string& message)
+      : Event(Event::Type::CHECKPOINT, timestamp), m_message(message) {}
+
+  /**
+   * @brief Get the checkpoint message.
+   */
+  std::string Message() const {
+    return m_message;
+  }
+
+ private:
+  std::string m_message;
+};
+
 /**
  * @brief Pretty print a measurement to a stream.
  */

src/scl/simulation/event.cc

@@ -60,6 +60,10 @@ auto EventTypeToString(Evt::Type type) {
     return "SEGMENT_END";
   }
 
+  if (type == Evt::Type::CHECKPOINT) {
+    return "CHECKPOINT";
+  }
+
   // if (type == scl::Measurement::Type::CLOSE)
   return "CLOSE";
 }
@@ -85,6 +89,10 @@ void WriteSegment(std::ostream& os, const scl::sim::SegmentEvent* m) {
   }
 }
 
+void WriteCheckpoint(std::ostream& os, const scl::sim::CheckpointEvent* m) {
+  os << " [" << m->Message() << "]";
+}
+
 }  // namespace
 
 std::ostream& scl::sim::operator<<(std::ostream& os, const Evt* m) {
@@ -111,5 +119,9 @@ std::ostream& scl::sim::operator<<(std::ostream& os, const Evt* m) {
     WriteRecv(os, dynamic_cast<const NetworkEvent*>(m));
   }
 
+  if (t == Evt::Type::CHECKPOINT) {
+    WriteCheckpoint(os, dynamic_cast<const CheckpointEvent*>(m));
+  }
+
   return os;
 }

src/scl/simulation/simulator.cc

@@ -155,7 +155,7 @@ std::vector<scl::sim::SimulationTrace> RunSimulation(
 
       scl::proto::ProtocolEnvironment env{
           networks[id],
-          std::make_unique<scl::sim::SimulatedClock>(ctx.get(), id),
+          std::make_unique<scl::sim::SimulatedClock>(ctx, id),
           std::make_unique<scl::sim::SimulatedThreadCtx>(ctx, id)};
 
       ps[id] = Run(ctx, id, ps[id].get(), env, output_callback);

test/scl/protocol/test_protocol.cc

@@ -121,6 +121,23 @@ TEST_CASE("Protocol env real-time clock", "[protocol]") {
   REQUIRE(d >= 100ms);
 }
 
+TEST_CASE("Protocol env real-time clock checkpoint", "[protocol]") {
+  // https://truong.io/posts/capturing_stdout_for_c++_unit_testing.html
+
+  proto::RealTimeClock clock;
+
+  std::stringstream buf;
+  std::streambuf* coutbuf = std::cout.rdbuf(buf.rdbuf());
+
+  clock.Checkpoint("asd");
+
+  auto output = buf.str();
+
+  std::cout.rdbuf(coutbuf);
+
+  REQUIRE_THAT(output, Catch::Matchers::StartsWith("asd @"));
+}
+
 TEST_CASE("Protocol env Stl thread context", "[protocol]") {
   proto::StlThreadContext ctx;
 

test/scl/simulation/test_env.cc

@@ -21,6 +21,7 @@
 #include "scl/simulation/config.h"
 #include "scl/simulation/context.h"
 #include "scl/simulation/env.h"
+#include "scl/simulation/event.h"
 #include "scl/simulation/mem_channel_buffer.h"
 
 using namespace scl;
@@ -44,7 +45,7 @@ TEST_CASE("Simulation env clock", "[sim]") {
   auto ctx = sim::SimulationContext::Create<sim::MemoryBackedChannelBuffer>(
       5,
       sim::DefaultConfigCreator());
-  sim::SimulatedClock clock(ctx.get(), 0);
+  sim::SimulatedClock clock(ctx, 0);
 
   ctx->AddEvent(0, SomeEvent());
   ctx->UpdateCheckpoint();
@@ -67,6 +68,25 @@ TEST_CASE("Simulation env clock", "[sim]") {
   REQUIRE(t2 < 1200ms);
 }
 
+TEST_CASE("Simulation env clock checkpoint", "[sim]") {
+  using namespace std::chrono_literals;
+
+  auto ctx = sim::SimulationContext::Create<sim::MemoryBackedChannelBuffer>(
+      5,
+      sim::DefaultConfigCreator());
+  sim::SimulatedClock clock(ctx, 0);
+
+  ctx->AddEvent(0, SomeEvent(10ms));
+  ctx->UpdateCheckpoint();
+  clock.Checkpoint("asd");
+  REQUIRE(ctx->Trace(0).size() == 2);
+  REQUIRE(ctx->Trace(0).back()->EventType() == sim::Event::Type::CHECKPOINT);
+  REQUIRE(ctx->Trace(0).back()->Timestamp() >= 10ms);
+
+  sim::CheckpointEvent* e = (sim::CheckpointEvent*)ctx->Trace(0).back().get();
+  REQUIRE(e->Message() == "asd");
+}
+
 TEST_CASE("Simulation env thread", "[sim]") {
   using namespace std::chrono_literals;
   auto ctx = sim::SimulationContext::Create<sim::MemoryBackedChannelBuffer>(
@@ -76,7 +96,7 @@ TEST_CASE("Simulation env thread", "[sim]") {
   ctx->UpdateCheckpoint();
 
   sim::SimulatedThreadCtx thread(ctx, 0);
-  sim::SimulatedClock clock(ctx.get(), 0);
+  sim::SimulatedClock clock(ctx, 0);
 
   ctx->AddEvent(0, SomeEvent(util::Time::Duration(1000ms)));
   thread.Sleep(1000000);