walk_power_graph.h

 
#ifndef BF_P4C_MAU_WALK_POWER_GRAPH_H_
#define BF_P4C_MAU_WALK_POWER_GRAPH_H_
 
#include <map>
#include <ostream>
#include <set>
 
#include "bf-p4c/bf-p4c-options.h"
#include "bf-p4c/mau/build_power_graph.h"
#include "bf-p4c/mau/determine_power_usage.h"
#include "bf-p4c/mau/jbay_next_table.h"
#include "bf-p4c/mau/mau_power.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/mau/table_dependency_graph.h"
#include "bf-p4c/phv/phv_fields.h"
#include "ir/gress.h"
#include "power_schema.h"
 
namespace MauPower {
 
class WalkPowerGraph : public MauInspector {
 public:
    using PowerLogging = Logging::Power_Schema_Logger;
    bool preorder(const IR::MAU::Table *t) override;
    void end_apply(const IR::Node *root) override;
    WalkPowerGraph(const NextTable *next_table_properties, BuildPowerGraph *graphs,
                   const bool &exceeds_stages,
                   const std::map<UniqueId, PowerMemoryAccess> &table_memory_access,
                   const BFN_Options &options, MauFeatures *mau_features,
                   std::map<gress_t, MprSettings *> &mpr_settings)
        : next_table_properties_(next_table_properties),
          graphs_(graphs),
          exceeds_stages_(exceeds_stages),
          options_(options),
          table_memory_access_(table_memory_access),
          mau_features_(mau_features),
          mpr_settings_(mpr_settings) {
        disable_mpr_config_ = options.disable_mpr_config;
        if (Device::currentDevice() != Device::TOFINO) {
            // This will not be necessary when turn on MPR by default.
            // disable_mpr_config_ = true;
        }
    }
 
 private:
    // inputs
    const NextTable *next_table_properties_;
    BuildPowerGraph *graphs_;
    const bool &exceeds_stages_;
    const BFN_Options &options_;
    const std::map<UniqueId, PowerMemoryAccess> &table_memory_access_;
    // modified
    MauFeatures *mau_features_;
    std::map<gress_t, MprSettings *> &mpr_settings_;
    // created
    PowerLogging *logger_ = nullptr;
    // Temporarily use this variable until can turn MPR on by default.
    bool disable_mpr_config_ = false;
    std::map<gress_t, double> gress_powers_real_ = {};
    std::map<gress_t, double> gress_powers_ = {};
    std::map<UniqueId, bool> on_critical_path_ = {};
    std::map<UniqueId, bool> always_powered_on_ = {};
    /*
     * Powered on due to latency difference between ingress & egress
     * JBAY-2889 HW Issue
     */
    std::map<UniqueId, bool> always_powered_on_latency_ = {};
    std::map<UniqueId, cstring> external_names_ = {};
    std::map<UniqueId, int> stages_ = {};
    std::map<UniqueId, gress_t> gress_map_ = {};
    size_t longest_table_name_ = 0;
 
    void clear_mpr_settings();
    void compute_mpr();
    bool check_mpr_conflict();  // check for ingress/egress match/action conflict
    double estimate_power();
    double estimate_power_tofino();
    double estimate_power_non_tofino();
 
    bool is_mpr_powered_on(gress_t g, int stage, const IR::MAU::Table *t) const;
 
    double traffic_limit_scaling(double pwr) const;
 
    void create_mau_power_json(const IR::Node *root);
    void produce_json_tables();
    void produce_json_total_power(int pipe_id);
    void produce_json_total_latency(int pipe_id);
    void produce_json_stage_characteristics();
 
    void create_mau_power_log(const IR::Node *root) const;
    void print_features(std::ofstream &out) const;
    void print_latency(std::ofstream &out) const;
    void print_mpr_settings(std::ofstream &out) const;
    void print_worst_power(std::ofstream &out) const;
};
 
}  // end namespace MauPower
 
#endif /* BF_P4C_MAU_WALK_POWER_GRAPH_H_ */