profile.hh

#pragma once
 
#include <cassert>
#include <cstddef>
#include <functional>
#include <memory>
#include <numeric>
#include <ostream>
#include <sstream>
#include <variant>
#include <vector>
 
namespace CppClingo::Ground {
 
 
enum class ProfileType : uint8_t {
    step, 
    accu  
};
 
enum class ProfileDetail : uint8_t {
    compact = 0,
    detailed = 1,
};
 
struct ProfileIndent {
  public:
    explicit ProfileIndent(size_t level, size_t width = 2) : level{level}, width{width} {}
 
    friend auto operator<<(std::ostream &out, ProfileIndent const &indent) -> std::ostream & {
        for (size_t i = 0; i < indent.level * indent.width; ++i) {
            out << ' ';
        }
        return out;
    }
 
    friend auto operator+(ProfileIndent const &indent, size_t add) -> ProfileIndent {
        return ProfileIndent{indent.level + add, indent.width};
    }
 
    friend auto operator+=(ProfileIndent &indent, size_t add) -> ProfileIndent & {
        indent.level += add;
        return indent;
    }
 
  private:
    size_t level;
    size_t width;
};
 
struct ProfileStats {
    ProfileStats() = default;
 
    void reset() { matches = instances = time_instantiate = time_propagate = 0; }
 
    void accumulate(ProfileStats const &stats, bool nested = false) {
        matches += stats.matches;
        instances += stats.instances;
        if (!nested) {
            time_instantiate += stats.time_instantiate;
            time_propagate += stats.time_propagate;
        }
    }
 
    void print(std::ostream &out, ProfileIndent indent) const;
 
    [[nodiscard]] auto score() const -> double {
        return static_cast<double>(time_instantiate) + static_cast<double>(time_propagate);
    }
 
    uint64_t matches = 0;
    uint64_t instances = 0;
    uint64_t time_instantiate = 0;
    uint64_t time_propagate = 0;
};
 
class ProfileNode {
  public:
    using Visitor = std::function<void(
        std::variant<std::pair<std::string_view, bool>, std::pair<ProfileStats const *, ProfileType>>, size_t)>;
 
    ProfileNode() = default;
    ProfileNode(ProfileNode const &other) = delete;
    auto operator=(ProfileNode const &other) -> ProfileNode & = delete;
 
    virtual ~ProfileNode() = default;
 
    void print(std::ostream &out, ProfileIndent indent, ProfileDetail detail, ProfileType type) const {
        do_print(out, indent, detail, type);
    }
 
    [[nodiscard]] auto equal(ProfileNode const &node) const -> bool { return do_equal(node); }
 
    [[nodiscard]] virtual auto score(ProfileType type) const -> double { return do_score(type); }
 
    virtual void begin_step() { do_begin_step(); }
 
    virtual void end_step() { do_end_step(); }
 
    virtual void combine(ProfileStats &stats, ProfileType type, bool nested) const { do_combine(stats, type, nested); }
 
    void accept(Visitor const &visit, size_t depth) const { do_accept(visit, depth); }
 
  private:
    virtual void do_print(std::ostream &out, ProfileIndent indent, ProfileDetail detail, ProfileType type) const = 0;
    [[nodiscard]] virtual auto do_equal(ProfileNode const &node) const -> bool = 0;
    [[nodiscard]] virtual auto do_score(ProfileType type) const -> double = 0;
    virtual void do_combine(ProfileStats &stats, ProfileType type, bool nested) const = 0;
    virtual void do_begin_step() = 0;
    virtual void do_end_step() = 0;
    virtual void do_accept(Visitor const &visit, size_t depth) const = 0;
};
 
class ProfileNodeInternal : public ProfileNode {
  public:
    template <class T> auto add_child(std::unique_ptr<T> child) -> T & {
        assert(child != nullptr);
        auto *ret = child.get();
        auto *ins = do_add_child(std::move(child));
        assert(dynamic_cast<T *>(ins) != nullptr);
        return ins != nullptr ? *static_cast<T *>(ins) : *ret;
    }
 
  private:
    virtual auto do_add_child(std::unique_ptr<ProfileNode> child) -> ProfileNode * = 0;
};
 
template <typename T> class ProfileNodeExpression : public ProfileNodeInternal {
  public:
    ProfileNodeExpression(T expr, bool nested = false) : expr_{std::move(expr)}, nested_{nested} {}
 
  private:
    auto do_add_child(std::unique_ptr<ProfileNode> child) -> ProfileNode * override {
        for (auto const &x : children_) {
            if (x->equal(*child)) {
                return x.get();
            }
        }
        children_.emplace_back(std::move(child));
        return children_.back().get();
    }
 
    void do_print(std::ostream &out, ProfileIndent indent, ProfileDetail detail, ProfileType type) const override {
        out << indent << (nested_ ? "[" : "") << expr_ << (nested_ ? "]" : "") << "\n";
        if (detail == ProfileDetail::detailed) {
            for (auto const &child : children_) {
                child->print(out, indent + 1, detail, type);
            }
        } else {
            auto stats = ProfileStats{};
            combine(stats, type, false);
            stats.print(out, indent + 1);
        }
    }
 
    [[nodiscard]] auto do_equal(ProfileNode const &node) const -> bool override {
        auto const *other = dynamic_cast<ProfileNodeExpression const *>(&node);
        if constexpr (requires { expr_.get(); }) {
            return other != nullptr && nested_ == other->nested_ && expr_.get() == other->expr_.get();
        } else {
            return other != nullptr && nested_ == other->nested_ && expr_ == other->expr_;
        }
    }
 
    [[nodiscard]] auto do_score(ProfileType type) const -> double override {
        return !nested_ ? std::accumulate(children_.begin(), children_.end(), 0.0,
                                          [=](double sum, auto const &child) { return sum + child->score(type); })
                        : 0;
    }
 
    void do_begin_step() override {
        for (auto &child : children_) {
            child->begin_step();
        }
    }
 
    void do_end_step() override {
        for (auto &child : children_) {
            child->end_step();
        }
    }
 
    void do_combine(ProfileStats &stats, ProfileType type, bool nested) const override {
        for (auto const &child : children_) {
            child->combine(stats, type, nested || nested_);
        }
    }
 
    void do_accept(Visitor const &visit, size_t depth) const override {
        std::ostringstream oss;
        oss << expr_;
        visit(std::make_pair(oss.view(), nested_), depth);
        for (auto const &child : children_) {
            child->accept(visit, depth + 1);
        }
    }
 
    T expr_;
    std::vector<std::unique_ptr<ProfileNode>> children_;
    bool nested_;
};
 
class ProfileData : public ProfileNode {
  public:
    ProfileData() = default;
 
  private:
    friend class Instantiator;
 
    void do_print(std::ostream &out, ProfileIndent indent, ProfileDetail detail, ProfileType type) const override {
        std::ignore = detail;
        type == ProfileType::step ? step_.print(out, indent) : accu_.print(out, indent);
    }
    [[nodiscard]] auto do_equal(ProfileNode const &node) const -> bool override {
        auto const *other = dynamic_cast<ProfileData const *>(&node);
        return other != nullptr;
    }
    [[nodiscard]] auto do_score(ProfileType type) const -> double override {
        return type == ProfileType::step ? step_.score() : accu_.score();
    }
    void do_begin_step() override { step_.reset(); }
    void do_end_step() override { accu_.accumulate(step_); }
    void do_combine(ProfileStats &stats, ProfileType type, bool nested) const override {
        if (type == ProfileType::step) {
            stats.accumulate(step_, nested);
        } else {
            stats.accumulate(accu_, nested);
        }
    }
 
    void do_accept(Visitor const &visit, size_t depth) const override {
        visit(std::make_pair(&step_, ProfileType::step), depth);
        visit(std::make_pair(&accu_, ProfileType::accu), depth);
    }
 
    ProfileStats step_;
    ProfileStats accu_;
};
 
 
} // namespace CppClingo::Ground