Ticket #618: 7a1a282efbb4.patch

lemon/time_measure.h

@@ -31 +31 @@
 #include <unistd.h>
 #include <sys/times.h>
 #include <sys/time.h>
+#include <csignal>
 #endif
 
+#include <cstring>
 #include <string>
 #include <fstream>
 #include <iostream>
+#include <vector>
+#include <lemon/error.h>
 #include <lemon/math.h>
 
 namespace lemon {
@@ -604 +608 @@
     return full/total;
   }
 
+  /// Base exception for time measure functions
+  class TimeMeasureException : public Exception {
+  public:
+    /// Constructor
+    TimeMeasureException() throw() {}
+    /// Virtual destructor
+    virtual ~TimeMeasureException() throw() {}
+    ///A short description of the exception
+    virtual const char* what() const throw() {
+      return "lemon::TimeMeasureException";
+    }
+  };
+
+  /// Exception thrown when time measuring fails
+  class TimeMeasureError : public TimeMeasureException {
+  public:
+    /// Constructor
+    TimeMeasureError() throw() {}
+    /// Virtual destructor
+    virtual ~TimeMeasureError() throw() {}
+    ///A short description of the exception
+    virtual const char* what() const throw() {
+      return "lemon::TimeMeasureError";
+    }
+  };
+
+  /// Exception thrown when the executed function times out
+  class TimeoutException : public TimeMeasureException {
+  public:
+    /// Constructor
+    TimeoutException() throw() {}
+    /// Virtual destructor
+    virtual ~TimeoutException() throw() {}
+    ///A short description of the exception
+    virtual const char* what() const throw() {
+      return "lemon::TimeoutException";
+    }
+  };
+
+  /// Exception thrown when the executed function throws an exception
+  class ExecutionException : public TimeMeasureException {
+  private:
+    std::string _message;
+    mutable std::string _what;
+  public:
+    /// Constructor
+    ExecutionException(const char* message, std::size_t len) throw() {
+      try {
+        _message.clear();
+        _message.assign(message, len);
+      } catch (...) {}
+    }
+    /// Virtual destructor
+    virtual ~ExecutionException() throw() {}
+    ///A short description of the exception
+    virtual const char* what() const throw() {
+      try {
+        _what.clear();
+        std::ostringstream oss;
+        oss << "lemon::ExecutionException: " << _message;
+        _what = oss.str();
+        return _what.c_str();
+      } catch (...) {}
+      return "lemon::ExecutionException";
+    }
+  };
+
+  namespace _time_measure_bits {
+#ifndef LEMON_WIN32
+    inline bool write_full(int fd, const void* buffer, std::size_t len) {
+      std::size_t offset = 0;
+      while (offset < len) {
+        ssize_t ret = write(fd, static_cast<const char*>(buffer) + offset, len - offset);
+        if (ret < 0) {
+          return false;
+        }
+        offset += ret;
+      }
+      return true;
+    }
+
+    inline bool read_full(int fd, void* buffer, std::size_t len) {
+      std::size_t offset = 0;
+      while (offset < len) {
+        ssize_t ret = read(fd, static_cast<char*>(buffer) + offset, len - offset);
+        if (ret < 0) {
+          return false;
+        }
+        offset += ret;
+      }
+      return true;
+    }
+#endif
+  }
+
+  /// Tool to measure the running time with a time constraint.
+
+  /// This function executes \c f on a forked subprocess, and if the subprocess
+  /// does not terminate in the given time constraint then it is killed by the
+  /// master process. Because \c f is executed in a subprocess, the side-effects
+  /// are not affecting the master process.
+  ///
+  /// Because WIN32 API does not have efficient \c fork() implementation, this
+  /// function is not implemented for Windows.
+
+  /// \param f the function object to be measured.
+  /// \param max_time the maximum total running time of \c f in seconds.
+  ///\return The running time of \c f reported by the subprocess.
+  template<class F>
+  TimeStamp constrainedRunningTimeTest(F f, double max_time)
+  {
+#ifndef LEMON_WIN32
+    int pipefd[2];
+    if (pipe(pipefd) == -1) {
+      throw TimeMeasureError();
+    }
+
+    pid_t cpid = fork();
+    if (cpid == -1) {
+      close(pipefd[0]);
+      close(pipefd[1]);
+      throw TimeMeasureError();
+    }
+
+    if (cpid == 0) {
+      close(pipefd[0]);
+      try {
+        Timer t;
+        f();
+        TimeStamp ts = t;
+        bool success = true;
+        _time_measure_bits::write_full(pipefd[1], &success, sizeof(success));
+        _time_measure_bits::write_full(pipefd[1], &ts, sizeof(ts));
+      } catch (const std::exception& e) {
+        const char* message = e.what();
+        size_t len = strlen(message);
+        bool success = false;
+        _time_measure_bits::write_full(pipefd[1], &success, sizeof(success));
+        _time_measure_bits::write_full(pipefd[1], &len, sizeof(len));
+        _time_measure_bits::write_full(pipefd[1], message, len);
+      } catch (...) {
+        static const char* message = "Unknown exception";
+        size_t len = strlen(message);
+        bool success = false;
+        _time_measure_bits::write_full(pipefd[1], &success, sizeof(bool));
+        _time_measure_bits::write_full(pipefd[1], &len, sizeof(len));
+        _time_measure_bits::write_full(pipefd[1], message, len);
+      }
+      close(pipefd[1]);
+      _exit(0);
+    } else {
+      close(pipefd[1]);
+
+      fd_set rfds;
+      FD_ZERO(&rfds);
+      FD_SET(pipefd[0], &rfds);
+
+      double sec_int, sec_frac;
+      sec_int = modf(max_time, &sec_frac);
+      struct timeval tv;
+      tv.tv_sec = sec_int;
+      tv.tv_usec = sec_frac * 1000000;
+
+      int sel = select(pipefd[0] + 1, &rfds, NULL, NULL, &tv);
+
+      if (sel < -1) {
+        close(pipefd[0]);
+        kill(cpid, SIGKILL);
+        throw TimeMeasureError();
+      }
+
+      if (sel == 0) {
+        close(pipefd[0]);
+        kill(cpid, SIGKILL);
+        throw TimeoutException();
+      } else {
+        bool success = false;
+        _time_measure_bits::read_full(pipefd[0], &success, sizeof(bool));
+        if (success) {
+          TimeStamp ts;
+          _time_measure_bits::read_full(pipefd[0], &ts, sizeof(ts));
+          close(pipefd[0]);
+          return ts;
+        } else {
+          size_t len;
+          _time_measure_bits::read_full(pipefd[0], &len, sizeof(len));
+          std::vector<char> buffer(len);
+          _time_measure_bits::read_full(pipefd[0], buffer.data(), len);
+          throw ExecutionException(buffer.data(), len);
+        }
+      }
+    }
+#else
+    throw TimeMeasureError();
+#endif
+  }
+
+
   /// @}
 
 

test/time_measure_test.cc

@@ -19 +19 @@
 #include <lemon/time_measure.h>
 #include <lemon/concept_check.h>
 
+#include "test_tools.h"
+
 using namespace lemon;
 
 void f()
@@ -39 +41 @@
     }
 }
 
+void h() {
+  while (true) {}
+}
+
+void i() {
+  throw std::exception();
+}
+
 int main()
 {
   Timer T;
@@ -56 +66 @@
   std::cout << t << " (" << n << " tests)\n";
   std::cout << "Total: " << full << "\n";
 
+#ifndef LEMON_WIN32
+  t=constrainedRunningTimeTest(f, 1);
+  std::cout << t << std::endl;
+
+  t=constrainedRunningTimeTest(g, 1);
+  std::cout << t << std::endl;
+
+  T.restart();
+  bool timed_out = false;
+  try {
+    t=constrainedRunningTimeTest(h, 1);
+  } catch (TimeoutException& e) {
+    std::cout << e.what() << std::endl;
+    timed_out = true;
+  }
+  check(timed_out, "Infinite loop has to time out.");
+  std::cout << T << std::endl;
+
+  T.restart();
+  bool execution_failed = false;
+  try {
+    t=constrainedRunningTimeTest(i, 1);
+  } catch (ExecutionException& e) {
+    std::cout << e.what() << std::endl;
+    execution_failed = true;
+  }
+  check(execution_failed, "Exception during the function execution.");
+  std::cout << T << std::endl;
+#endif
+
   return 0;
 }