src/tools/fuzzing/fuzz-stats.cpp - external/github.com/WebAssembly/binaryen.git - Git at Google

 /*
  * 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
	/*
	* 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