src/tools/fuzzing/fuzz-stats.cpp

/*
 * Copyright 2026 WebAssembly Community Group participants
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "tools/fuzzing/fuzz-stats.h"
#include "support/file_lock.h"

#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <sstream>

namespace wasm {

namespace {

std::string getStatsFilename() {
  if (const char* env = getenv("BINARYEN_FUZZ_STATS")) {
    if (env[0] != '\0') {
      std::string str(env);
      if (str == "1" || str == "true" || str == "on" || str == "yes") {
        return "fuzz-stats.txt";
      }
      return str;
    }
  }
  return "";
}

struct PatternStatsRecord {
  uint64_t occurrences = 0;
  uint64_t inModules = 0;
  uint64_t inFunctions = 0;
};

std::mutex eventsMutex;
std::map<std::string, std::map<int, uint64_t>> pendingEvents;

void saveStats(bool hasModuleStats,
               uint64_t numFunctions,
               const std::map<std::string, uint64_t>* occurrences,
               const std::map<std::string, uint64_t>* funcMatches) {
  std::string filename = getStatsFilename();
  if (filename.empty()) {
    return;
  }

  std::map<std::string, std::map<int, uint64_t>> localEvents;
  {
    std::lock_guard<std::mutex> lock(eventsMutex);
    localEvents.swap(pendingEvents);
  }

  if (!hasModuleStats && localEvents.empty()) {
    return;
  }

  // Lock file for safe concurrent updates across processes.
  FileLock lock(filename + ".lock");

  // Read existing statistics from file if present.
  uint64_t totalModules = 0;
  uint64_t totalFunctions = 0;
  std::map<std::string, PatternStatsRecord> statsMap;
  std::map<std::string, std::map<int, uint64_t>> eventStatsMap;

  enum class Section { None, Patterns, Events };

  {
    std::ifstream in(filename);
    if (in.is_open()) {
      std::string line;
      Section section = Section::None;
      std::string currentEvent;
      while (std::getline(in, line)) {
        if (!line.empty() && line.back() == '\r') {
          line.pop_back();
        }
        if (line.empty() || line[0] == '#') {
          continue;
        }
        if (line == "Patterns:") {
          section = Section::Patterns;
          continue;
        }
        if (line == "Events:") {
          section = Section::Events;
          currentEvent.clear();
          continue;
        }
        if (section == Section::Events) {
          if (line.rfind("    ", 0) == 0) {
            std::stringstream ss(line);
            int outcome = 0;
            char colon = 0;
            uint64_t count = 0;
            if (!currentEvent.empty() && (ss >> outcome >> colon) &&
                colon == ':' && (ss >> count)) {
              eventStatsMap[currentEvent][outcome] = count;
            }
          } else if (line.rfind("  ", 0) == 0) {
            currentEvent = line.substr(2);
            if (!currentEvent.empty() && currentEvent.back() == ':') {
              currentEvent.pop_back();
            }
          }
          continue;
        }

        std::stringstream ss(line);
        std::string key;
        if (ss >> key) {
          if (key == "Modules:") {
            ss >> totalModules;
          } else if (key == "Functions:") {
            ss >> totalFunctions;
          } else if (section == Section::Patterns) {
            std::string name = key;
            uint64_t occurrencesCount = 0;
            std::string perModStr, perFuncStr;
            uint64_t inMods = 0;
            std::string pctModStr;
            uint64_t inFuncs = 0;
            std::string pctFuncStr;
            if (ss >> occurrencesCount >> perModStr >> perFuncStr >> inMods >>
                pctModStr >> inFuncs >> pctFuncStr) {
              statsMap[name] = {occurrencesCount, inMods, inFuncs};
            } else {
              statsMap[name].occurrences = occurrencesCount;
            }
          }
        }
      }
    }
  }

  // Accumulate current run into overall statistics.
  if (hasModuleStats) {
    totalModules += 1;
    totalFunctions += numFunctions;

    if (occurrences && funcMatches) {
      for (const auto& [name, count] : *occurrences) {
        auto& record = statsMap[name];
        record.occurrences += count;
        record.inFunctions += funcMatches->at(name);
        if (count > 0) {
          record.inModules += 1;
        }
      }
    }
  }

  for (const auto& [eventName, outcomes] : localEvents) {
    for (const auto& [outcome, count] : outcomes) {
      eventStatsMap[eventName][outcome] += count;
    }
  }

  // Write updated statistics to a temporary file and atomically rename.
  std::string tmpFilename = filename + ".tmp";
  {
    std::ofstream out(tmpFilename);
    if (!out.is_open()) {
      return;
    }

    out << "# Binaryen Fuzzing Statistics\n";
    out << "Modules: " << totalModules << "\n";
    out << "Functions: " << totalFunctions << "\n";

    if (!statsMap.empty()) {
      out << "\nPatterns:\n";
      out << "# " << std::left << std::setw(30) << "Name" << std::right
          << std::setw(12) << "Occurrences" << std::setw(14) << "Per Module"
          << std::setw(14) << "Per Function" << std::setw(10) << "Modules"
          << std::setw(12) << "% Modules" << std::setw(12) << "Functions"
          << std::setw(14) << "% Functions"
          << "\n";

      for (const auto& [name, data] : statsMap) {
        double perMod =
          totalModules > 0 ? (double)data.occurrences / totalModules : 0.0;
        double perFunc =
          totalFunctions > 0 ? (double)data.occurrences / totalFunctions : 0.0;
        double pctMod =
          totalModules > 0 ? (100.0 * data.inModules) / totalModules : 0.0;
        double pctFunc = totalFunctions > 0
                           ? (100.0 * data.inFunctions) / totalFunctions
                           : 0.0;

        std::ostringstream pctModStream, pctFuncStream;
        pctModStream << std::fixed << std::setprecision(2) << pctMod << "%";
        pctFuncStream << std::fixed << std::setprecision(2) << pctFunc << "%";

        out << "  " << std::left << std::setw(30) << name << std::right
            << std::setw(12) << data.occurrences << std::setw(14) << std::fixed
            << std::setprecision(4) << perMod << std::setw(14) << std::fixed
            << std::setprecision(4) << perFunc << std::setw(10)
            << data.inModules << std::setw(12) << pctModStream.str()
            << std::setw(12) << data.inFunctions << std::setw(14)
            << pctFuncStream.str() << "\n";
      }
    }

    if (!eventStatsMap.empty()) {
      out << "\nEvents:\n";
      for (const auto& [eventName, outcomes] : eventStatsMap) {
        uint64_t totalEventCount = 0;
        for (const auto& [outcome, count] : outcomes) {
          totalEventCount += count;
        }
        out << "  " << eventName << ":\n";
        for (const auto& [outcome, count] : outcomes) {
          double pct =
            totalEventCount > 0 ? (100.0 * count) / totalEventCount : 0.0;
          std::ostringstream pctStream;
          pctStream << std::fixed << std::setprecision(2) << pct << "%";
          out << "    " << std::left << std::setw(8)
              << (std::to_string(outcome) + ":") << std::right << std::setw(12)
              << count << " (" << std::setw(7) << pctStream.str() << ")\n";
        }
      }
    }
  }

  rename(tmpFilename.c_str(), filename.c_str());

  if (getenv("BINARYEN_FUZZ_STATS_VERBOSE")) {
    std::cerr << "Fuzz stats updated in " << filename
              << " (Total Modules: " << totalModules
              << ", Total Functions: " << totalFunctions << ")\n";
  }
}

struct EventFlusher {
  ~EventFlusher() { saveStats(false, 0, nullptr, nullptr); }
} eventFlusher;

} // namespace

namespace FuzzStats {

bool isEnabled() {
  static const bool enabled = !getStatsFilename().empty();
  return enabled;
}

int recordEvent(const std::string& name, int outcome) {
  if (!isEnabled()) {
    return outcome;
  }
  std::lock_guard<std::mutex> lock(eventsMutex);
  pendingEvents[name][outcome]++;
  return outcome;
}

int recordEvent(const std::string& name,
                const char* file,
                int line,
                int outcome) {
  if (!isEnabled()) {
    return outcome;
  }
  const char* filename = file;
  for (const char* p = file; *p; ++p) {
    if (*p == '/' || *p == '\\') {
      filename = p + 1;
    }
  }
  return recordEvent(name + " (" + filename + ":" + std::to_string(line) + ")",
                     outcome);
}

void save(uint64_t numFunctions,
          const std::map<std::string, uint64_t>& occurrences,
          const std::map<std::string, uint64_t>& funcMatches) {
  saveStats(true, numFunctions, &occurrences, &funcMatches);
}

} // namespace FuzzStats

} // namespace wasm