log.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <functional>
#include <sstream>
#include <string>
#include <vector>
 
#include "barretenberg/env/logstr.hpp"
#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
 
#define BENCHMARK_INFO_PREFIX "##BENCHMARK_INFO_PREFIX##"
#define BENCHMARK_INFO_SEPARATOR "#"
#define BENCHMARK_INFO_SUFFIX "##BENCHMARK_INFO_SUFFIX##"
 
#define BENCH_GATE_COUNT_START(builder, op_name)                                                                       \
    uint64_t __bench_before = builder.get_num_finalized_gates_inefficient();
 
#define BENCH_GATE_COUNT_END(builder, op_name)                                                                         \
    uint64_t __bench_after = builder.get_num_finalized_gates_inefficient();                                            \
    std::cerr << "num gates with " << op_name << " = " << __bench_after - __bench_before << std::endl;                 \
    benchmark_info(Builder::NAME_STRING, "Bigfield", op_name, "Gate Count", __bench_after - __bench_before);
 
template <typename... Args> std::string format(Args... args)
{
    std::ostringstream os;
    ((os << args), ...);
    return os.str();
}
 
template <typename T> void benchmark_format_chain(std::ostream& os, T const& first)
{
    // We will be saving these values to a CSV file, so we can't tolerate commas
    std::stringstream current_argument;
    current_argument << first;
    std::string current_argument_string = current_argument.str();
    std::ranges::replace(current_argument_string, ',', ';');
    os << current_argument_string << BENCHMARK_INFO_SUFFIX;
}
 
template <typename T, typename... Args>
void benchmark_format_chain(std::ostream& os, T const& first, Args const&... args)
{
    // We will be saving these values to a CSV file, so we can't tolerate commas
    std::stringstream current_argument;
    current_argument << first;
    std::string current_argument_string = current_argument.str();
    std::ranges::replace(current_argument_string, ',', ';');
    os << current_argument_string << BENCHMARK_INFO_SEPARATOR;
    benchmark_format_chain(os, args...);
}
 
template <typename... Args> std::string benchmark_format(Args... args)
{
    std::ostringstream os;
    os << BENCHMARK_INFO_PREFIX;
    benchmark_format_chain(os, args...);
    return os.str();
}
 
enum class LogLevel : int {
    DEBUG = 0,
    INFO = 1,
    VERBOSE = 2,
    IMPORTANT = 3,
};
 
// This allows the logging sink to be customized. Useful for Typescript use-cases.
using LogFunction = std::function<void(LogLevel level, const char* msg)>;
extern LogFunction log_function;
void set_log_function(LogFunction new_log_function);
 
extern bool debug_logging;
// In release mode (e.g., NDEBUG is defined), we don't compile debug logs.
#ifndef NDEBUG
#define debug(...) debug_([&]() { return format(__VA_ARGS__); })
#else
#define debug(...) (void)0
#endif
 
// We take a function so that evaluation is lazy.
inline void debug_(std::function<std::string()> func)
{
    if (debug_logging) {
        log_function(LogLevel::DEBUG, func().c_str());
    }
}
 
template <typename... Args> inline void info(Args... args)
{
    log_function(LogLevel::INFO, format(args...).c_str());
}
 
#define vinfo(...) vinfo_([&]() { return format(__VA_ARGS__); })
 
extern bool verbose_logging;
inline void vinfo_(std::function<std::string()> func)
{
    if (verbose_logging) {
        log_function(LogLevel::VERBOSE, func().c_str());
    }
}
 
template <typename... Args> inline void important(Args... args)
{
    log_function(LogLevel::IMPORTANT, format("important: ", args...).c_str());
}
 
#ifdef CI
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
inline void benchmark_info(Arg1 composer, Arg2 class_name, Arg3 operation, Arg4 metric, Arg5 value)
{
    logstr(benchmark_format(composer, class_name, operation, metric, value).c_str());
}
#else
template <typename... Args> inline void benchmark_info(Args... /*unused*/) {}
#endif
 
class BenchmarkInfoCollator {
 
    std::vector<std::string> saved_benchmarks;
 
  public:
    BenchmarkInfoCollator() = default;
    BenchmarkInfoCollator(const BenchmarkInfoCollator& other) = default;
    BenchmarkInfoCollator(BenchmarkInfoCollator&& other) = default;
    BenchmarkInfoCollator& operator=(const BenchmarkInfoCollator& other) = default;
    BenchmarkInfoCollator& operator=(BenchmarkInfoCollator&& other) = default;
 
#ifdef CI
    template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    inline void benchmark_info_deferred(Arg1 composer, Arg2 class_name, Arg3 operation, Arg4 metric, Arg5 value)
    {
        saved_benchmarks.push_back(benchmark_format(composer, class_name, operation, metric, value).c_str());
    }
#else
    explicit BenchmarkInfoCollator(std::vector<std::string> saved_benchmarks)
        : saved_benchmarks(std::move(saved_benchmarks))
    {}
    template <typename... Args> inline void benchmark_info_deferred(Args... /*unused*/) {}
#endif
    ~BenchmarkInfoCollator()
    {
        for (auto& x : saved_benchmarks) {
            logstr(x.c_str());
        }
    }
};