Add TimeoutPerTest for generation tests for project

Author: Saveliy Grigoryev

lib/Runner/run_klee.cpp

@@ -60,6 +60,7 @@
 #include <signal.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <thread>
 #include <unistd.h>
 
 #include <cerrno>
@@ -154,6 +155,10 @@ cl::opt<bool> InteractiveMode("interactive",
                               cl::desc("Launch klee in interactive mode."),
                               cl::init(false), cl::cat(StartCat));
 
+cl::opt<int> TimeoutPerFunction("timeout-per-function",
+                                cl::desc("Timeout per function in klee."),
+                                cl::init(0), cl::cat(StartCat));
+
 cl::opt<std::string>
     EntryPointsFile("entrypoints-file",
                     cl::desc("Path to file with entrypoints name."),
@@ -1575,6 +1580,43 @@ static int run_klee_on_function(
   return 0;
 }
 
+void kill_child(pid_t child_pid) {
+  if (kill(child_pid, 0) != 0) {
+    return;
+  }
+  int statusSIGTERM = kill(child_pid, SIGTERM);
+  std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  if (kill(child_pid, 0) == 0) {
+    int statusSIGKILL = kill(child_pid, SIGKILL);
+    if (statusSIGKILL != 0) {
+      klee_error("Kill with signal SIGKILL return nonzero code.");
+    }
+  }
+}
+
+void wait_until_any_child_dies(const std::vector<std::pair<pid_t,
+      std::chrono::time_point<std::chrono::steady_clock>>> &child_processes) {
+  while (true) {
+    bool something_dead = false;
+    for (const auto &child_process : child_processes) {
+      if (kill(child_process.first, 0) != 0) {
+        something_dead = true;
+      }
+      auto current_time = std::chrono::steady_clock::now();
+      auto duration_function = std::chrono::duration_cast<std::chrono::seconds>(current_time - 
+                               child_process.second).count();
+      if (duration_function > TimeoutPerFunction) {
+        kill_child(child_process.first);
+        something_dead = true;
+      }
+    }
+    if (something_dead) {
+      break;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+}
+
 int run_klee(int argc, char **argv, char **envp) {
   if (theInterpreter) {
     theInterpreter = nullptr;
@@ -1881,29 +1923,36 @@ int run_klee(int argc, char **argv, char **envp) {
 
     SmallString<128> outputDirectory = handler->getOutputDirectory();
     const int PROCESS = ProcessNumber;
-    std::vector<pid_t> child_process;
+    using time_point = std::chrono::time_point<std::chrono::steady_clock>;
+    std::vector<std::pair<pid_t, time_point>> child_processes;
+    signal(SIGCHLD, SIG_IGN);
     while (true) {
       std::string entrypoint;
       if (!(entrypoints >> entrypoint)) {
         break;
       }
 
-      if (child_process.size() == PROCESS) {
-        wait(NULL);
+      if (child_processes.size() == PROCESS) {
+        if (TimeoutPerFunction != 0) {
+          wait_until_any_child_dies(child_processes);
+        } else {
+          wait(NULL);
+        }
       }
 
-      std::vector<pid_t> alive_child;
-      for (const pid_t child_id : child_process) {
-        if (kill(child_id, 0) == 0) {
-          alive_child.push_back(child_id);
+      std::vector<std::pair<pid_t, time_point>> alive_child;
+      for (const auto &child_process : child_processes) {
+        if (kill(child_process.first, 0) == 0) {
+          alive_child.push_back(child_process);
         }
       }
-      child_process = alive_child;
+      child_processes = alive_child;
 
       pid_t pid = fork();
       if (pid < 0) {
         klee_error("%s", "Cannot create child process.");
       } else if (pid == 0) {
+        signal(SIGCHLD, SIG_DFL);
         EntryPoint = entrypoint;
         SmallString<128> newOutputDirectory = outputDirectory;
         sys::path::append(newOutputDirectory, entrypoint);
@@ -1912,12 +1961,25 @@ int run_klee(int argc, char **argv, char **envp) {
                              finalModule, replayPath, loadedModules);
         exit(0);
       } else {
-        child_process.push_back(pid);
+        child_processes.emplace_back(pid, std::chrono::steady_clock::now());
       }
     }
 
-    while (wait(NULL) > 0)
-      ;
+    if (TimeoutPerFunction != 0) {
+      while (!child_processes.empty()) {
+        wait_until_any_child_dies(child_processes);
+
+        std::vector<std::pair<pid_t, time_point>> alive_child;
+        for (const auto &child_process : child_processes) {
+          if (kill(child_process.first, 0) == 0) {
+            alive_child.push_back(child_process);
+          }
+        }
+        child_processes = alive_child;
+      }
+    } else {
+      while (wait(NULL) > 0);
+    }
   } else {
     run_klee_on_function(pArgc, pArgv, pEnvp, handler, interpreter, finalModule,
                          replayPath, loadedModules);

test/InteractiveMode/interactive_mode.c

@@ -0,0 +1,92 @@
+// RUN: %clang %s -emit-llvm -g %O0opt -c -o %t.bc
+// RUN: rm -rf %t.klee-out %t.entrypoints
+// RUN: echo sign_sum >> %t.entrypoints
+// RUN: echo comparison >> %t.entrypoints
+// RUN: echo segment_intersection >> %t.entrypoints
+// RUN: echo main >> %t.entrypoints
+// RUN: %klee --output-dir=%t.klee-out --entry-point=main --interactive --entrypoints-file=%t.entrypoints %t.bc
+
+// RUN: test -f %t.klee-out/sign_sum/test000001.ktestjson
+// RUN: test -f %t.klee-out/sign_sum/test000002.ktestjson
+// RUN: test -f %t.klee-out/sign_sum/test000003.ktestjson
+// RUN: not test -f %t.klee-out/sign_sum/test000004.ktestjson
+
+// RUN: test -f %t.klee-out/comparison/test000001.ktestjson
+// RUN: test -f %t.klee-out/comparison/test000002.ktestjson
+// RUN: not test -f %t.klee-out/comparison/test000003.ktestjson
+
+// RUN: test -f %t.klee-out/segment_intersection/test000001.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000002.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000003.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000004.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000005.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000006.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000007.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000008.ktestjson
+// RUN: test -f %t.klee-out/segment_intersection/test000009.ktestjson
+// RUN: not test -f %t.klee-out/segment_intersection/test000010.ktestjson
+
+// RUN: test -f %t.klee-out/main/test000001.ktestjson
+// RUN: not test -f %t.klee-out/main/test000002.ktestjson
+
+#include "klee/klee.h"
+#include <stdio.h>
+
+int sign_sum() {
+  int x, y;
+  klee_make_symbolic(&x, sizeof(int), "x");
+  klee_make_symbolic(&y, sizeof(int), "y");
+
+  int c = 0;
+  if (x + y > 0) {
+    c = 1;
+  } else if (x + y < 0) {
+    c = -1;
+  } else {
+    c = 0;
+  }
+  return 0;
+}
+
+int comparison() {
+  int x, y;
+  klee_make_symbolic(&x, sizeof(int), "x");
+  klee_make_symbolic(&y, sizeof(int), "y");
+
+  if (x < y) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int segment_intersection() {
+  int l, r, A, B;
+  klee_make_symbolic(&l, sizeof(int), "l");
+  klee_make_symbolic(&r, sizeof(int), "r");
+  klee_make_symbolic(&A, sizeof(int), "A");
+  klee_make_symbolic(&B, sizeof(int), "B");
+
+  if (l > r || A > B) {
+    return -1;
+  }
+
+  if (l > B || r < A) {
+    return 0;
+  }
+
+  if (A <= l && r <= B) {
+    return r - l;
+  }
+
+  if (l <= A && B <= r) {
+    return B - A;
+  }
+
+  return (r <= B ? r : B) - (l >= A ? l : A);
+}
+
+int main() {
+  return 0;
+}
+