no higher-order timed_execution()

Signed-off-by: Elazar Gershuni <[email protected]>

src/crab_verifier.hpp

@@ -28,6 +28,8 @@ class Invariants final {
 
   public:
     explicit Invariants(crab::invariant_table_t&& invariants) : invariants(std::move(invariants)) {}
+    explicit Invariants(Invariants&& invariants) = default;
+    explicit Invariants(const Invariants& invariants) = default;
 
     bool is_valid_after(const label_t& label, const string_invariant& state) const;
     void print_invariants(std::ostream& os, const cfg_t& cfg) const;

src/main/check.cpp

@@ -12,7 +12,6 @@
 #include "memsize_linux.hpp"
 #endif
 #include "linux_verifier.hpp"
-#include "utils.hpp"
 
 // Avoid affecting other headers by macros.
 #include "CLI11/CLI11.hpp"
@@ -245,7 +244,11 @@ int main(int argc, char** argv) {
                 std::cout << "\n";
                 return 0;
             }
-            const auto [invariants, seconds] = timed_execution([&] { return analyze(cfg); });
+            const auto begin = std::chrono::steady_clock::now();
+            auto invariants = analyze(cfg);
+            const auto end = std::chrono::steady_clock::now();
+            const auto seconds = std::chrono::duration<double>(end - begin).count();
+
             if (ebpf_verifier_options.verbosity_opts.print_invariants) {
                 invariants.print_invariants(std::cout, cfg);
             }

src/main/linux_verifier.cpp

@@ -2,15 +2,13 @@
 // SPDX-License-Identifier: MIT
 #if __linux__
 
-#include <ctime>
 #include <linux/bpf.h>
 #include <tuple>
 #include <unistd.h>
 
 #include "config.hpp"
 #include "linux_verifier.hpp"
 #include "spec_type_descriptors.hpp"
-#include "utils.hpp"
 
 static int do_bpf(const bpf_cmd cmd, union bpf_attr& attr) { return syscall(321, cmd, &attr, sizeof(attr)); }
 
@@ -25,7 +23,7 @@ std::tuple<bool, double> bpf_verify_program(const EbpfProgramType& type, const s
     buf[0] = 0;
     memset(buf.data(), '\0', buf.size());
 
-    union bpf_attr attr{};
+    union bpf_attr attr {};
     memset(&attr, '\0', sizeof(attr));
     attr.prog_type = gsl::narrow<__u32>(type.platform_specific_data);
     attr.insn_cnt = gsl::narrow<__u32>(raw_prog.size());
@@ -39,14 +37,18 @@ std::tuple<bool, double> bpf_verify_program(const EbpfProgramType& type, const s
     attr.kern_version = 0x041800;
     attr.prog_flags = 0;
 
-    const auto [res, elapsed_secs] = timed_execution([&] { return do_bpf(BPF_PROG_LOAD, attr); });
+    const auto begin = std::chrono::steady_clock::now();
+    const int res = do_bpf(BPF_PROG_LOAD, attr);
+    const auto end = std::chrono::steady_clock::now();
+    const auto seconds = std::chrono::duration<double>(end - begin).count();
+
     if (res < 0) {
         if (options->verbosity_opts.print_failures) {
             std::cerr << "Failed to verify program: " << strerror(errno) << " (" << errno << ")\n";
             std::cerr << "LOG: " << reinterpret_cast<char*>(attr.log_buf);
         }
-        return {false, elapsed_secs};
+        return {false, seconds};
     }
-    return {true, elapsed_secs};
+    return {true, seconds};
 }
 #endif

src/test/ebpf_yaml.cpp

@@ -246,7 +246,7 @@ std::optional<Failure> run_yaml_test_case(TestCase test_case, bool debug) {
     thread_local_options = test_case.options;
     try {
         const cfg_t cfg = prepare_cfg(test_case.instruction_seq, info, test_case.options.cfg_opts);
-        auto invariants = analyze(cfg, test_case.assumed_pre_invariant);
+        const Invariants invariants = analyze(cfg, test_case.assumed_pre_invariant);
         const string_invariant actual_last_invariant = invariants.invariant_at(label_t::exit);
         const std::set<string> actual_messages = invariants.check_assertions(cfg).all_messages();
 
@@ -366,7 +366,7 @@ ConformanceTestResult run_conformance_test_case(const std::vector<std::byte>& me
 
     try {
         const cfg_t cfg = prepare_cfg(prog, info, options.cfg_opts);
-        auto invariants = analyze(cfg, pre_invariant);
+        const Invariants invariants = analyze(cfg, pre_invariant);
         return ConformanceTestResult{.success = invariants.verified(cfg), .r0_value = invariants.exit_value()};
     } catch (const std::exception&) {
         // Catch exceptions thrown in ebpf_domain.cpp.