try to adding timeout

Author: 1-coder

HW3.sln

@@ -15,6 +15,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Shared", "Shared", "{5AB057
 		Shared\shared_utils.h = Shared\shared_utils.h
 		Shared\stopwatch.h = Shared\stopwatch.h
 		Shared\stopwatch_decorator.h = Shared\stopwatch_decorator.h
+		Shared\timeout.h = Shared\timeout.h
 	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KargerSteinMinCut", "KargerSteinMinCut\KargerSteinMinCut.vcxproj", "{8DA0F624-4588-4226-8A15-32674C1B39FA}"

KargerMinCut/karger.h

@@ -8,23 +8,27 @@
 #include "AdjacencyMapGraph.h"
 #include "full_contraction.h"
 #include "stopwatch_decorator.h"
+#include "timeout.h"
 
 /**
  * Run Karger's randomized min-cut algorithm k times on the given graph.
  * Return the a tuple containing the min-cut found and the discovery time.
  * Time: O(n^4 * log(n))
  * Space: O(n + m)
  */
-[[nodiscard]] auto karger(const std::shared_ptr<AdjacencyMapGraph>& graph, size_t k,
+[[nodiscard]] auto karger(timeout::timeout_signal& signal,
+                          const std::shared_ptr<AdjacencyMapGraph>& graph, size_t k,
                           const stopwatch::time_point_t program_time_start) noexcept {
     // keep track of the min-cut discovery time
     stopwatch::time_point_t discovery_time_stop;
 
     // keeps track of the minimum cut
     size_t min_cut = std::numeric_limits<size_t>::max();
 
+    bool keep_going = true;
+
     // execute full_contraction k times to hopefully find the minimum cut.
-    for (size_t i = 0; i < k; ++i) {
+    for (size_t i = 0; i < k && keep_going; ++i) {
         // get the contracted graph and the full_contraction execution time in microseconds
         const auto [contracted_graph, full_contraction_duration] =
             stopwatch::decorator<stopwatch::us_t>(full_contraction)(graph, 2);
@@ -39,6 +43,8 @@
         }
 
         std::cout << "full_contraction: " << full_contraction_duration << '\n';
+
+        keep_going = !signal.is_expired();
     }
 
     // number of microseconds needed to find the lowest cut among all k full_contraction iterations

KargerMinCut/main.cpp

@@ -5,6 +5,8 @@
 #include "read_file.h"
 #include "shared_utils.h"
 #include "stopwatch_decorator.h"
+#include "timeout.h"
+
 
 int main(int argc, char** argv) {
     using namespace std::string_literals;
@@ -29,8 +31,14 @@ int main(int argc, char** argv) {
 
     std::cout << "k: "s << k << '\n';
 
-    const auto [min_cut, discovery_time, karger_duration] =
-        stopwatch::decorator<stopwatch::us_t>(karger)(graph, k, program_time_start);
+        // the timeout is set to 2 minutes
+    auto timeout_min = 2min;
+
+    const auto [min_cut, discovery_time, karger_duration] = timeout::with_timeout(
+        &timeout_min, &stopwatch::decorator<stopwatch::us_t>(karger), &graph, &k, &program_time_start);
+
+   
+    //stopwatch::decorator<stopwatch::us_t>(karger)(graph, k, program_time_start);
 
     // stop the stopwatch
     auto program_time_stop = stopwatch::now();

Shared/timeout.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <chrono>              // std::milliseconds, std::chrono_literals
+#include <future>              // std::future, std::promise
+#include <thread>              // std::thread
+#include <type_traits>         // std::invoke_result_t
+
+using namespace std::chrono_literals;
+
+namespace timeout {
+    namespace detail {
+        // returns true iff the given future was terminated by a timeout
+        template <typename R>
+        bool is_expired(std::future<R> const& future) noexcept {
+            return future.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready;
+        }
+    }  // namespace detail
+
+    // future<void> wrapper used to signal expired timeout signals
+    struct timeout_signal {
+        timeout_signal() = delete;
+
+        explicit timeout_signal(std::future<void>&& signal_future) :
+            signal_future(std::move(signal_future)) {
+        }
+
+        // returns true iff the timeout expired
+        [[nodiscard]] bool is_expired() const {
+            return detail::is_expired(signal_future);
+        }
+
+        // create a new timeout_signal from a promise
+        static timeout_signal from_promise(std::promise<void>& promise) {
+            return timeout_signal{promise.get_future()};
+        }
+
+    private:
+        std::future<void> signal_future;
+    };
+
+    // execute a function f with the given arguments with a timeout guard of the specified duration.
+    // The first argument of f must be a timeout_signal&& object.
+    // The function is executed in a separate thread. The caller thread is blocked until either
+    // the function returns or the timeout expires, whatever of the two conditions happens earlier.
+    // If the function concludes before the timeout expires, the result is immediately returned.
+    // If the timeout expires while the function is still in execution, its timeout signal object is
+    // marked as expired. The function itself must check whether the timeout signal was triggered or
+    // not with the timeout_signal::is_expired() mmethod.
+    template <typename Duration, typename Function, class... Args>
+    std::invoke_result_t<Function, timeout_signal&&, Args...> with_timeout(Duration duration,
+                                                                           Function&& f,
+                                                                           Args&&... args) {
+        using R = std::invoke_result_t<Function, timeout_signal&&, Args...>;
+
+        // create promise and timeout for signaling the timeout expiration
+        std::promise<void> promise_signal;
+        timeout_signal signal{timeout_signal::from_promise(promise_signal)};
+
+        // we create a task to run the function f in a separate thread
+        std::packaged_task<R(timeout_signal&&, Args...)> task(f);
+        std::future<R> future = task.get_future();
+
+        // start the function in a new thread. The timeout signal object is the first argument of
+        // the function.
+        std::thread thread(std::move(task), std::move(signal), std::forward<Args>(args)...);
+
+        // if the packaged function returns before the timeout expired, return its
+        // result.
+        if (future.wait_for(duration) == std::future_status::timeout) {
+            // the allotted timeout expired.
+            // Tell the function thread to exit the function immediately
+            promise_signal.set_value();
+        }
+
+        // wait for thread to join
+        thread.join();
+
+        // return the function result
+        return future.get();
+    }
+}  // namespace timeout