support write profile file

Author: butterunderflow

benchmarks/pldi2026/btree/compile.py

@@ -45,6 +45,8 @@ def compile_all(cpp_files=None, flags=None):
         cmd = ["g++", str(cpp), "-o", str(out)] + flags
         print("Compiling:", cpp.name)
         try:
+            print("  Executing command:")
+            print("   ", " ".join(cmd))
             proc = subprocess.run(cmd, capture_output=True, text=True)
         except FileNotFoundError:
             print("Error: g++ not found. Install a C++ compiler.")

headers/wasm/concolic_driver.hpp

@@ -7,6 +7,7 @@
 #include "smt_solver.hpp"
 #include "symbolic_rt.hpp"
 #include "utils.hpp"
+#include "output_report.hpp"
 #include <cassert>
 #include <chrono>
 #include <functional>
@@ -48,7 +49,7 @@ class ManagedConcolicCleanup {
     if (driver.tree_file.has_value())
       ExploreTree.dump_graphviz(driver.tree_file.value());
 
-      // Clear the symbol bookkeeper
+    // Clear the symbol bookkeeper
     SymBookKeeper.clear();
   }
 };
@@ -134,8 +135,10 @@ inline void ConcolicDriver::main_exploration_loop() {
 
 inline void ConcolicDriver::run() {
   main_exploration_loop();
-  ExploreTree.print_overall_result();
+  auto overall = ExploreTree.read_current_overall_result();
+  overall.print();
   Profile.print_summary();
+  dump_all_summary_json(Profile, overall);
 }
 
 static void start_concolic_execution_with(

headers/wasm/output_report.hpp

@@ -0,0 +1,54 @@
+#ifndef WASM_OUTPUT_REPORT_HPP
+#define WASM_OUTPUT_REPORT_HPP
+
+#include "profile.hpp"
+#include "symbolic_rt.hpp"
+#include "config.hpp"
+#include <filesystem>
+
+inline void dump_all_summary_json(const Profile_t &profile,
+                                  const OverallResult &overall) {
+  // use environment variable OUTPUT_DIR to config particular output directory
+  // use environment variable OUTPUT_DIR to config particular output directory
+  const char *output_dir = std::getenv("OUTPUT_DIR");
+  if (output_dir == nullptr) {
+    return;
+  }
+
+  std::filesystem::path outdir(output_dir);
+
+  std::filesystem::path report_path =
+      outdir / std::filesystem::path("concolic_execution_report.json");
+
+  auto parent = report_path.parent_path();
+  if (!parent.empty()) {
+    std::error_code ec;
+    std::filesystem::create_directories(parent, ec);
+    if (ec) {
+      throw std::runtime_error("Failed to create output directory: " +
+                               ec.message());
+    }
+  }
+
+  std::ofstream ofs(report_path);
+  if (!ofs.is_open()) {
+    throw std::runtime_error("Failed to open " + report_path.string() +
+                             " for writing");
+  }
+
+  // Simple JSON dump (pretty-printed)
+  ofs << "{\n";
+  ofs << "  \"unexplored_count\": " << overall.unexplored_count << ",\n";
+  ofs << "  \"finished_count\": " << overall.finished_count << ",\n";
+  ofs << "  \"failed_count\": " << overall.failed_count << ",\n";
+  ofs << "  \"not_to_explore_count\": " << overall.not_to_explore_count
+      << ",\n";
+  ofs << "  \"unreachable_count\": " << overall.unreachable_count;
+  if (PROFILE_STEP || PROFILE_TIME) {
+    ofs << ",\n";
+    profile.write_as_json(ofs);
+  }
+  ofs << "}\n";
+  ofs.close();
+}
+#endif // WASM_OUTPUT_REPORT_HPP

headers/wasm/profile.hpp

@@ -116,12 +116,70 @@ class Profile_t {
     }
   }
 
+  void write_as_json(std::ostream &os) const {
+    os << "  \"profile_summary\": {\n";
+    if (PROFILE_STEP) {
+      os << "    \"total_push_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::PUSH)] << ",\n";
+      os << "    \"total_pop_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::POP)] << ",\n";
+      os << "    \"total_peek_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::PEEK)] << ",\n";
+      os << "    \"total_shift_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::SHIFT)] << ",\n";
+      os << "    \"total_set_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::SET)] << ",\n";
+      os << "    \"total_get_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::GET)] << ",\n";
+      os << "    \"total_binary_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::BINARY)]
+         << ",\n";
+      os << "    \"total_tree_fill_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::TREE_FILL)]
+         << ",\n";
+      os << "    \"total_cursor_move_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::CURSOR_MOVE)]
+         << ",\n";
+      os << "    \"total_other_instructions_executed\": " << step_count
+         << ",\n";
+      os << "    \"total_mem_grow_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::MEM_GROW)]
+         << ",\n";
+      os << "    \"total_snapshot_create_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::SNAPSHOT_CREATE)]
+         << ",\n";
+      os << "    \"total_sym_eval_operations\": "
+         << op_count[static_cast<std::size_t>(StepProfileKind::SYM_EVAL)]
+         << "\n";
+    }
+    if (PROFILE_TIME) {
+      os << "    \"total_time_instruction_execution_s\": "
+         << std::setprecision(15)
+         << time_count[static_cast<std::size_t>(TimeProfileKind::INSTR)]
+         << ",\n";
+      os << "    \"total_time_solver_s\": "
+         << std::setprecision(15)
+         << time_count[static_cast<std::size_t>(TimeProfileKind::SOLVER)]
+         << ",\n";
+      os << "    \"total_time_resuming_from_snapshot_s\": "
+         << std::setprecision(15)
+         << time_count[static_cast<std::size_t>(
+                TimeProfileKind::RESUME_SNAPSHOT)]
+         << ",\n";
+      os << "    \"total_time_counting_symbolic_size_s\": "
+         << std::setprecision(15)
+         << time_count[static_cast<std::size_t>(
+                TimeProfileKind::COUNT_SYM_SIZE)]
+         << "\n";
+    }
+    os << "  }\n";
+  }
+
   // record the time spent in main instruction execution, in seconds
   void add_instruction_time(TimeProfileKind kind, double time) {
     time_count[static_cast<std::size_t>(kind)] += time;
   }
 
-private:
   int step_count;
   std::array<int, static_cast<std::size_t>(StepProfileKind::OperationCount)>
       op_count;

headers/wasm/symbolic_rt.hpp

@@ -14,6 +14,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
+#include <filesystem>
 #include <fstream>
 #include <iterator>
 #include <memory>
@@ -884,6 +885,24 @@ inline int Snapshot_t::cost_of_snapshot() {
   return 5.336 *
          (cost_of_stack_copy + cost_of_frame_copy + cost_of_memory_copy);
 }
+
+struct OverallResult {
+  int unexplored_count = 0;
+  int finished_count = 0;
+  int failed_count = 0;
+  int not_to_explore_count = 0;
+  int unreachable_count = 0;
+
+  void print() {
+    std::cout << "Explore Tree Overall Result:" << std::endl;
+    std::cout << "  Unexplored paths: " << unexplored_count << std::endl;
+    std::cout << "  Finished paths: " << finished_count << std::endl;
+    std::cout << "  Failed paths: " << failed_count << std::endl;
+    std::cout << "  Unreachable paths: " << unreachable_count << std::endl;
+    std::cout << "  NotToExplore paths: " << not_to_explore_count << std::endl;
+  }
+};
+
 class ExploreTree_t {
 public:
   explicit ExploreTree_t()
@@ -1009,6 +1028,16 @@ class ExploreTree_t {
   }
 
   std::monostate dump_graphviz(std::string filepath) {
+    std::filesystem::path out_path(filepath);
+    auto parent = out_path.parent_path();
+    if (!parent.empty()) {
+      std::error_code ec;
+      std::filesystem::create_directories(parent, ec);
+      if (ec) {
+        throw std::runtime_error("Failed to create output directory: " +
+                                 ec.message());
+      }
+    }
     std::ofstream ofs(filepath);
     if (!ofs.is_open()) {
       throw std::runtime_error("Failed to open " + filepath + "  for writing");
@@ -1017,45 +1046,35 @@ class ExploreTree_t {
     return std::monostate();
   }
 
-  std::monostate print_overall_result() {
-    // Print how many paths have been explored, how many paths are unreachable,
-    // how many paths are failed, how many paths are finished successfully
-    int unexplored_count = 0;
-    int finished_count = 0;
-    int failed_count = 0;
-    int not_to_explore_count = 0;
-    int unreachable_count = 0;
+  OverallResult read_current_overall_result() {
+    OverallResult result;
     std::function<void(NodeBox *)> dfs = [&](NodeBox *node) {
       if (auto if_else_node = dynamic_cast<IfElseNode *>(node->node.get())) {
         dfs(if_else_node->true_branch.get());
         dfs(if_else_node->false_branch.get());
       } else if (dynamic_cast<UnExploredNode *>(node->node.get())) {
-        unexplored_count += 1;
+        result.unexplored_count += 1;
       } else if (dynamic_cast<Finished *>(node->node.get())) {
-        finished_count += 1;
+        result.finished_count += 1;
       } else if (dynamic_cast<Failed *>(node->node.get())) {
-        failed_count += 1;
+        result.failed_count += 1;
       } else if (dynamic_cast<Unreachable *>(node->node.get())) {
-        unreachable_count += 1;
+        result.unreachable_count += 1;
       } else if (dynamic_cast<SnapshotNode *>(node->node.get())) {
         // Snapshot node is considered unexplored
-        unexplored_count += 1;
+        result.unexplored_count += 1;
       } else if (dynamic_cast<NotToExploreNode *>(node->node.get())) {
-        not_to_explore_count += 1;
+        result.not_to_explore_count += 1;
       } else {
         throw std::runtime_error("Unknown node type in explore tree");
       }
     };
     dfs(root.get());
-    std::cout << "Explore Tree Overall Result:" << std::endl;
-    std::cout << "  Unexplored paths: " << unexplored_count << std::endl;
-    std::cout << "  Finished paths: " << finished_count << std::endl;
-    std::cout << "  Failed paths: " << failed_count << std::endl;
-    std::cout << "  Unreachable paths: " << unreachable_count << std::endl;
-    std::cout << "  NotToExplore paths: " << not_to_explore_count << std::endl;
-    return std::monostate();
+    return result;
   }
 
+  std::monostate print_overall_result() {}
+
   NodeBox *pick_unexplored() {
     // Pick an unexplored node from the tree
     // For now, we just iterate through the tree and return the first unexplored