Move TimeConstrained from setSubstitutionSystem$cpp to libSetReplace (#647)

## Changes

* Moves `TimeConstrained[...]` from `setSubstitutionSystem$cpp[...]` to inside `HypergraphSubstitutionSystem.cpp` in `libSetReplace`.
* Adds a new `TerminationReasonCode`: `8 -> "TimeConstrained"`.

## Comments

* `AbsoluteTiming` doesn't really match the time constraint:

```wl
In[] := WolframModel[
             {{1, 2}} -> {{1, 3}, {1, 3}, {3, 2}}, {{1, 1}},
             Infinity,
             TimeConstraint -> 1] // AbsoluteTiming // First
Out[] = 2.61478
```

## Examples

```wl
In[] := WolframModel[{{1, 2}} -> {{1, 3}, {1, 3}, {3, 2}}, {{1, 1}}, Infinity, TimeConstraint -> 1]
```

![image](https://user-images.githubusercontent.com/40190339/118748655-b54bb000-b821-11eb-8b80-84c04b004e05.png)

```wl
In[] := %["TerminationReason"]
Out[] = "TimeConstraint"
```

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/maxitg/setreplace/647)
<!-- Reviewable:end -->

Author: daneelsan

Kernel/setSubstitutionSystem$cpp.m

@@ -20,7 +20,8 @@
 importLibSetReplaceFunction[
   "hypergraphSubstitutionSystemReplace" -> cpp$setReplace,
   {Integer,                   (* set ID *)
-   {Integer, 1, "Constant"}}, (* {events, generations, atoms, max expressions per atom, expressions} *)
+   {Integer, 1, "Constant"},  (* {events, generations, atoms, max expressions per atom, expressions} *)
+   Real},                     (* time constraint *)
   "Void"];
 
 importLibSetReplaceFunction[
@@ -114,7 +115,8 @@
   4 -> $maxFinalVertexDegree,
   5 -> $maxFinalExpressions,
   6 -> $fixedPoint,
-  7 -> $Aborted
+  7 -> $Aborted,
+  8 -> $timeConstraint
 |>;
 
 (* GlobalSpacelike is syntactic sugar for "EventSelectionFunction" -> "MultiwaySpacelike", "MaxDestroyerEvents" -> 1 *)
@@ -174,24 +176,30 @@
     Replace[eventDeduplication, $eventDeduplicationCodes],
     IntegerDigits[RandomInteger[{0, $maxUInt32}], 2^16, 2]
   ];
-  TimeConstrained[
-    CheckAbort[
-      cpp$setReplace[
-        setID,
-        stepSpec /@ {
-            $maxEvents, $maxGenerationsLocal, $maxFinalVertices, $maxFinalVertexDegree, $maxFinalExpressions} /.
-          {Infinity | (_ ? MissingQ) -> $unset}],
-      If[!returnOnAbortQ, Abort[], terminationReason = $Aborted]],
-    timeConstraint,
-    If[!returnOnAbortQ, Return[$Aborted], terminationReason = $timeConstraint]];
+
+  CheckAbort[
+    cpp$setReplace[
+      setID,
+      stepSpec /@ {
+          $maxEvents, $maxGenerationsLocal, $maxFinalVertices, $maxFinalVertexDegree, $maxFinalExpressions} /.
+        {Infinity | (_ ? MissingQ) -> $unset},
+      timeConstraint /. Infinity -> $unset]
+  ,
+    If[!returnOnAbortQ, Abort[]]
+  ];
+
+  terminationReason = $terminationReasonCodes[cpp$terminationReason[setID]];
+  If[(terminationReason === $timeConstraint) && !returnOnAbortQ, Return @ $Aborted];
+  terminationReason = Replace[terminationReason, $notTerminated -> $timeConstraint];
+
   numericAtomLists = decodeAtomLists[cpp$setExpressions[setID]];
   events = decodeEvents[cpp$setEvents[setID]];
   maxCompleteGeneration = CheckAbort[
-    Replace[cpp$maxCompleteGeneration[setID], LibraryFunctionError[___] -> Missing["Unknown", $Aborted]],
-    If[!returnOnAbortQ, Abort[], terminationReason = $Aborted; Missing["Unknown", $Aborted]]];
-  terminationReason = Replace[$terminationReasonCodes[cpp$terminationReason[setID]], {
-    $Aborted -> terminationReason,
-    $notTerminated -> $timeConstraint}];
+    Replace[cpp$maxCompleteGeneration[setID], LibraryFunctionError[___] -> Missing["Unknown", $Aborted]]
+  ,
+    If[!returnOnAbortQ, Abort[], Missing["Unknown", $Aborted]]
+  ];
+
   resultAtoms = Union[Catenate[numericAtomLists]];
   inversePartialGlobalMap = Association[Reverse /@ Normal @ globalIndex];
   inverseGlobalMap = Association @ Thread[resultAtoms

libSetReplace/HypergraphSubstitutionSystem.cpp

@@ -56,7 +56,7 @@ class HypergraphSubstitutionSystem::Implementation {
               return causalGraph_.tokenSeparation(first, second);
             }) {}
 
-  int64_t replaceOnce(const std::function<bool()> shouldAbort, bool resetStepSpec = false) {
+  int64_t replaceOnce(const std::function<bool()> shouldAbortOrTimeOut, bool resetStepSpec = false) {
     if (resetStepSpec) {
       updateStepSpec(StepSpecification{});
     }
@@ -67,11 +67,7 @@ class HypergraphSubstitutionSystem::Implementation {
       return 0;
     }
 
-    indexNewTokens([this, &shouldAbort]() {
-      const bool isAborted = shouldAbort();
-      if (isAborted) terminationReason_ = TerminationReason::Aborted;
-      return isAborted;
-    });
+    indexNewTokens(shouldAbortOrTimeOut);
     if (matcher_.empty()) {
       if (causalGraph_.largestGeneration() == stepSpec_.maxGenerationsLocal) {
         terminationReason_ = TerminationReason::MaxGenerationsLocal;
@@ -130,14 +126,35 @@ class HypergraphSubstitutionSystem::Implementation {
     return 1;
   }
 
-  int64_t replace(const StepSpecification stepSpec, const std::function<bool()>& shouldAbort) {
+  int64_t replace(const StepSpecification stepSpec,
+                  const std::function<bool()>& shouldAbort,
+                  std::chrono::steady_clock::duration const timeConstraint) {
     updateStepSpec(stepSpec);
     int64_t count = 0;
     if (maxDestroyerEvents_ == 0) {
       return count;
     }
+
+    auto startTime = std::chrono::steady_clock::now();
+    const std::function<bool()> shouldTimeOut = [startTime, timeConstraint]() {
+      return (std::chrono::steady_clock::now() - startTime) > timeConstraint;
+    };
+
+    const std::function<bool()> shouldAbortOrTimeOut = [this, &shouldAbort, &shouldTimeOut]() {
+      if (shouldAbort()) {
+        terminationReason_ = TerminationReason::Aborted;
+        return true;
+      }
+      if (shouldTimeOut()) {
+        terminationReason_ = TerminationReason::TimeConstrained;
+        return true;
+      }
+
+      return false;
+    };
+
     while (true) {
-      if (replaceOnce(shouldAbort)) {
+      if (replaceOnce(shouldAbortOrTimeOut)) {
         ++count;
       } else {
         return count;
@@ -402,8 +419,9 @@ int64_t HypergraphSubstitutionSystem::replaceOnce(const std::function<bool()>& s
 }
 
 int64_t HypergraphSubstitutionSystem::replace(const StepSpecification& stepSpec,
-                                              const std::function<bool()>& shouldAbort) {
-  return implementation_->replace(stepSpec, shouldAbort);
+                                              const std::function<bool()>& shouldAbort,
+                                              std::chrono::steady_clock::duration const timeConstraint) {
+  return implementation_->replace(stepSpec, shouldAbort, timeConstraint);
 }
 
 std::vector<AtomsVector> HypergraphSubstitutionSystem::tokens() const { return implementation_->tokens(); }

libSetReplace/HypergraphSubstitutionSystem.hpp

@@ -1,6 +1,7 @@
 #ifndef LIBSETREPLACE_HYPERGRAPHSUBSTITUTIONSYSTEM_HPP_
 #define LIBSETREPLACE_HYPERGRAPHSUBSTITUTIONSYSTEM_HPP_
 
+#include <chrono>
 #include <functional>
 #include <limits>
 #include <memory>
@@ -29,6 +30,9 @@ class HypergraphSubstitutionSystem {
 
   static constexpr int64_t stepLimitDisabled = std::numeric_limits<int64_t>::max();
 
+  static constexpr std::chrono::steady_clock::duration timeConstraintDisabled =
+      std::chrono::steady_clock::duration::max();
+
   /** @brief Specification of conditions upon which to stop evaluation.
    * @details Each of these is UpTo, i.e., the evaluation is terminated when the first of these, fixed point, or an
    * abort is reached.
@@ -59,7 +63,8 @@ class HypergraphSubstitutionSystem {
     MaxFinalAtomDegree = 4,
     MaxFinalTokens = 5,
     Complete = 6,
-    Aborted = 7
+    Aborted = 7,
+    TimeConstrained = 8,
   };
 
   /** @brief Creates a new hypergraph system with given evaluation rules, and initial condition.
@@ -78,17 +83,20 @@ class HypergraphSubstitutionSystem {
                                unsigned int randomSeed = 0);
 
   /** @brief Perform a single substitution, create the corresponding event, and output tokens.
-   * @param shouldAbort function that should return true if abort is requested.
+   * @param shouldAbortOrTimeOut function that should return true if abort is requested or the evolution timed out.
    * @return 1 if substitution was made, 0 if no matches were found.
    */
-  int64_t replaceOnce(const std::function<bool()>& shouldAbort);
+  int64_t replaceOnce(const std::function<bool()>& shouldAbortOrTimeOut);
 
   /** @brief Run replaceOnce() stepSpec.maxEvents times, or until the next token violates constraints imposed by
    * stepSpec.
    * @param shouldAbort function that should return true if abort is requested.
+   * @param timeConstraint number of seconds before timing out the evolution.
    * @return The number of subtitutions made, could be between 0 and stepSpec.maxEvents.
    */
-  int64_t replace(const StepSpecification& stepSpec, const std::function<bool()>& shouldAbort);
+  int64_t replace(const StepSpecification& stepSpec,
+                  const std::function<bool()>& shouldAbort,
+                  std::chrono::steady_clock::duration const timeConstraint = timeConstraintDisabled);
 
   /** @brief List of all tokens in the system, past and present.
    */

libSetReplace/WolframLanguageAPI.cpp

@@ -296,7 +296,7 @@ int hypergraphSubstitutionSystemReplace(WolframLibraryData libData,
                                         mint argc,
                                         MArgument* argv,
                                         [[maybe_unused]] MArgument result) {
-  if (argc != 2) {
+  if (argc != 3) {
     return LIBRARY_FUNCTION_ERROR;
   }
 
@@ -308,8 +308,15 @@ int hypergraphSubstitutionSystemReplace(WolframLibraryData libData,
     return LIBRARY_FUNCTION_ERROR;
   }
 
+  const double timeConstraintWL = MArgument_getReal(argv[2]);
+  auto timeConstraint = HypergraphSubstitutionSystem::timeConstraintDisabled;
+  if (timeConstraintWL > 0) {
+    timeConstraint = std::chrono::duration_cast<std::chrono::steady_clock::duration>(
+        std::chrono::duration<double>(timeConstraintWL));
+  }
+
   try {
-    hypergraphSubstitutionSystemFromID(systemID).replace(stepSpec, shouldAbort(libData));
+    hypergraphSubstitutionSystemFromID(systemID).replace(stepSpec, shouldAbort(libData), timeConstraint);
   } catch (...) {
     return LIBRARY_FUNCTION_ERROR;
   }