instruction_selection.h

 
#ifndef BF_P4C_MAU_INSTRUCTION_SELECTION_H_
#define BF_P4C_MAU_INSTRUCTION_SELECTION_H_
 
#include "bf-p4c/bf-p4c-options.h"
#include "bf-p4c/common/utils.h"
#include "bf-p4c/ir/tofino_write_context.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/mau/reduction_or.h"
#include "bf-p4c/phv/phv_fields.h"
#include "ir/ir-generated.h"
 
using namespace P4;
 
class UnimplementedRegisterMethodCalls : public MauInspector {
    bool preorder(const IR::MAU::Primitive *prim) override;
 
 public:
    UnimplementedRegisterMethodCalls() {}
};
 
class ToFunnelShiftInstruction : public MauTransform {
    const IR::Expression *preorder(IR::Cast *) override;
 
 public:
    ToFunnelShiftInstruction() {}
};
 
class ConvertFunnelShiftExtern : public MauTransform {
    const IR::Expression *preorder(IR::Primitive *) override;
 
 public:
    ConvertFunnelShiftExtern() {}
};
 
class HashGenSetup : public PassManager {
    ordered_map<const IR::Expression *, IR::MAU::HashGenExpression *> hash_gen_injections;
    ordered_set<const IR::Expression *> hash_dist_injections;
    const PhvInfo &phv;
    const BFN_Options &options;
 
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = PassManager::init_apply(node);
        hash_gen_injections.clear();
        hash_dist_injections.clear();
        return rv;
    }
 
    class CreateHashGenExprs : public MauInspector, TofinoWriteContext {
        HashGenSetup &self;
        std::vector<const IR::Expression *> per_prim_hge;
        bool preorder(const IR::MAU::StatefulAlu *) override { return false; }
        bool preorder(const IR::BFN::SignExtend *) override;
        bool preorder(const IR::Concat *) override;
        bool preorder(const IR::Expression *) override;
        bool preorder(const IR::Constant *) override;
        bool preorder(const IR::MAU::Primitive *) override;
        void postorder(const IR::MAU::Primitive *) override;
 
        void check_for_symmetric(const IR::Declaration_Instance *decl, const IR::ListExpression *le,
                                 IR::MAU::HashFunction hf, LTBitMatrix *sym_keys);
        bool isBetter(const IR::Expression *dest, const IR::Expression *a, const IR::Expression *b);
 
     public:
        explicit CreateHashGenExprs(HashGenSetup &s) : self(s) {}
    };
 
    class ScanHashDists : public MauInspector {
        HashGenSetup &self;
        bool preorder(const IR::MAU::StatefulAlu *) override { return false; }
        bool preorder(const IR::Expression *) override;
 
     public:
        explicit ScanHashDists(HashGenSetup &s) : self(s) {}
    };
 
    class UpdateHashDists : public MauTransform {
        HashGenSetup &self;
        const IR::Expression *postorder(IR::Expression *) override;
 
     public:
        explicit UpdateHashDists(HashGenSetup &s) : self(s) {}
    };
 
 public:
    explicit HashGenSetup(const PhvInfo &p, const BFN_Options &o) : phv(p), options(o) {
        addPasses(
            {new CreateHashGenExprs(*this), new ScanHashDists(*this), new UpdateHashDists(*this)});
    }
};
 
class Synth2PortSetup : public MauTransform {
    safe_vector<const IR::MAU::Primitive *> stateful;
    std::set<UniqueAttachedId> per_flow_enables;
    std::map<UniqueAttachedId, IR::MAU::MeterType> meter_types;
 
    safe_vector<IR::MAU::Instruction *> created_instrs;
 
    const IR::MAU::Action *preorder(IR::MAU::Action *) override;
    const IR::Node *postorder(IR::MAU::Primitive *) override;
    const IR::MAU::Action *postorder(IR::MAU::Action *) override;
 
    void clear_action() {
        stateful.clear();
        per_flow_enables.clear();
        meter_types.clear();
    }
 
 public:
    explicit Synth2PortSetup(const PhvInfo &) {}
};
 
class DoInstructionSelection : public MauTransform, TofinoWriteContext {
    const PhvInfo &phv;
    IR::MAU::Action *af = nullptr;
    class SplitInstructions;
    int synth_arg_num = 0;
    const IR::MAU::TableSeq *ts = nullptr;
    ordered_map<cstring, const IR::MAU::Instruction *> const_to_phv;
 
    profile_t init_apply(const IR::Node *root) override;
    const IR::MAU::HashDist *preorder(IR::MAU::HashDist *hd) override {
        prune();
        return hd;
    }
    const IR::GlobalRef *preorder(IR::GlobalRef *) override;
    const IR::MAU::TableSeq *postorder(IR::MAU::TableSeq *) override;
    const IR::MAU::Action *postorder(IR::MAU::Action *) override;
    const IR::MAU::Action *preorder(IR::MAU::Action *) override;
    const IR::MAU::SaluAction *preorder(IR::MAU::SaluAction *a) override {
        prune();
        return a;
    }
    const IR::Expression *postorder(IR::Add *) override;
    const IR::Expression *postorder(IR::AddSat *) override;
    const IR::Expression *postorder(IR::Sub *) override;
    const IR::Expression *postorder(IR::SubSat *) override;
    const IR::Expression *postorder(IR::Neg *) override;
    const IR::Expression *postorder(IR::Shr *) override;
    const IR::Expression *postorder(IR::Shl *) override;
    const IR::Expression *postorder(IR::BAnd *) override;
    const IR::Expression *postorder(IR::BOr *) override;
    const IR::Expression *postorder(IR::BXor *) override;
    const IR::Expression *postorder(IR::Cmpl *) override;
    const IR::Expression *preorder(IR::BFN::SignExtend *) override;
    const IR::Expression *preorder(IR::Concat *) override;
    // const IR::Expression *postorder(IR::Cast *) override;
    const IR::Expression *postorder(IR::Operation_Relation *) override;
    const IR::Expression *postorder(IR::Mux *) override;
    const IR::Slice *postorder(IR::Slice *) override;
    const IR::Expression *postorder(IR::BoolLiteral *) override;
    const IR::Node *postorder(IR::MAU::Primitive *) override;
    const IR::MAU::Instruction *postorder(IR::MAU::Instruction *i) override { return i; }
 
    bool checkPHV(const IR::Expression *);
    bool checkActionBus(const IR::Expression *e);
    bool checkSrc1(const IR::Expression *);
    bool checkConst(const IR::Expression *ex, long &value);
    bool equiv(const IR::Expression *a, const IR::Expression *b);
    IR::Member *genIntrinsicMetadata(gress_t gress, cstring header, cstring field);
 
    void limitWidth(const IR::Expression *);
 
 public:
    explicit DoInstructionSelection(const PhvInfo &phv) : phv(phv) {}
};
 
class StatefulAttachmentSetup : public PassManager {
    const PhvInfo &phv;
    const IR::TempVar *saved_tempvar = nullptr;
    const IR::MAU::HashDist *saved_hashdist = nullptr;
    typedef std::pair<const IR::MAU::AttachedMemory *, const IR::MAU::Table *> HashDistKey;
    typedef std::pair<const IR::MAU::StatefulCall *, const IR::MAU::Table *> StatefulCallKey;
    ordered_set<cstring> remove_tempvars;
    ordered_set<cstring> copy_propagated_tempvars;
    ordered_set<const IR::Node *> remove_instr;
    ordered_map<cstring, const IR::MAU::HashDist *> stateful_alu_from_hash_dists;
    ordered_map<HashDistKey, const IR::MAU::HashDist *> update_hd;
    ordered_map<StatefulCallKey, const IR::Expression *> update_calls;
    typedef IR::MAU::StatefulUse use_t;
    ordered_map<const IR::MAU::Action *, ordered_map<const IR::MAU::AttachedMemory *, use_t>>
        action_use;
    typedef std::pair<const IR::MAU::Synth2Port *, const IR::MAU::Table *> IndexCheck;
    struct clear_info_t {
        const IR::MAU::AttachedMemory *attached = 0;
        bitvec clear_value;
        uint32_t busy_value = 0;
    };
    ordered_map<const IR::MAU::AttachedMemory *, clear_info_t> salu_clears;
    ordered_map<const IR::MAU::Table *, clear_info_t *> table_clears;
 
    ordered_set<IndexCheck> addressed_by_hash;
    ordered_set<IndexCheck> addressed_by_index;
 
    profile_t init_apply(const IR::Node *root) override {
        remove_tempvars.clear();
        copy_propagated_tempvars.clear();
        remove_instr.clear();
        stateful_alu_from_hash_dists.clear();
        update_hd.clear();
        return PassManager::init_apply(root);
    }
    class Scan : public MauInspector, TofinoWriteContext {
        StatefulAttachmentSetup &self;
        bool preorder(const IR::MAU::Action *) override;
        bool preorder(const IR::MAU::Instruction *) override;
        bool preorder(const IR::TempVar *) override;
        bool preorder(const IR::MAU::HashDist *) override;
        void postorder(const IR::MAU::Instruction *) override;
        void postorder(const IR::MAU::Primitive *) override;
        void postorder(const IR::MAU::Table *) override;
        void setup_index_operand(const IR::Expression *index_expr,
                                 const IR::MAU::Synth2Port *synth2port, const IR::MAU::Table *tbl,
                                 const IR::MAU::StatefulCall *call);
        void simpl_concat(std::vector<const IR::Expression *> &slices, const IR::Concat *concat);
 
     public:
        explicit Scan(StatefulAttachmentSetup &self) : self(self) {}
    };
    class Update : public MauTransform {
        StatefulAttachmentSetup &self;
        const IR::MAU::StatefulCall *preorder(IR::MAU::StatefulCall *) override;
        const IR::MAU::BackendAttached *preorder(IR::MAU::BackendAttached *ba) override;
        const IR::MAU::StatefulAlu *preorder(IR::MAU::StatefulAlu *salu) override;
        const IR::MAU::Instruction *preorder(IR::MAU::Instruction *sp) override;
 
     public:
        explicit Update(StatefulAttachmentSetup &self) : self(self) {
            dontForwardChildrenBeforePreorder = true;
        }
    };
 
    const IR::MAU::HashDist *find_hash_dist(const IR::Expression *expr,
                                            const IR::MAU::Primitive *prim);
    IR::MAU::HashDist *create_hash_dist(const IR::Expression *e, const IR::MAU::Primitive *prim);
 
 public:
    explicit StatefulAttachmentSetup(const PhvInfo &p) : phv(p) {
        addPasses({new Scan(*this), new Update(*this)});
    }
};
 
class NullifyAllStatefulCallPrim : public MauModifier {
    bool preorder(IR::MAU::StatefulCall *sc) override;
 
 public:
    NullifyAllStatefulCallPrim() {}
};
 
class BackendCopyPropagation : public MauTransform, TofinoWriteContext {
    const PhvInfo &phv;
    struct FieldImpact {
        le_bitrange dest_bits;
        const IR::Expression *read;
 
     public:
        FieldImpact(le_bitrange db, const IR::Expression *r) : dest_bits(db), read(r) {}
        const IR::Expression *getSlice(bool isSalu, le_bitrange bits);
    };
    ordered_map<const PHV::Field *, safe_vector<FieldImpact>> copy_propagation_replacements;
    bool elem_copy_propagated = false;
    IR::Vector<IR::MAU::Primitive> *split_set = nullptr;
 
    const IR::Node *preorder(IR::Node *n) override {
        visitOnce();
        return n;
    }
    const IR::Node *preorder(IR::MAU::Instruction *i) override;
    const IR::MAU::StatefulCall *preorder(IR::MAU::StatefulCall *sc) override {
        prune();
        return sc;
    }
    const IR::MAU::Action *preorder(IR::MAU::Action *a) override;
    const IR::Expression *preorder(IR::Expression *a) override;
    void update(const IR::MAU::Instruction *instr, const IR::Expression *e);
    const IR::Expression *propagate(const IR::MAU::Instruction *instr, const IR::Expression *e);
    const IR::MAU::Action *postorder(IR::MAU::Action *) override;
 
 public:
    explicit BackendCopyPropagation(const PhvInfo &p) : phv(p) { visitDagOnce = false; }
};
 
class VerifyParallelWritesAndReads : public MauInspector, TofinoWriteContext {
 public:
    typedef ordered_map<const PHV::Field *, safe_vector<le_bitrange>> FieldWrites;
 
 private:
    const PhvInfo &phv;
    FieldWrites writes;
 
    bool preorder(const IR::MAU::Action *) override;
    void postorder(const IR::MAU::Instruction *) override;
    bool preorder(const IR::MAU::StatefulCall *) override { return false; }
    bool preorder(const IR::MAU::BackendAttached *) override { return false; }
 
 public:
    explicit VerifyParallelWritesAndReads(const PhvInfo &p) : phv(p) {}
};
 
class EliminateAllButLastWrite : public PassManager {
    const PhvInfo &phv;
 
 public:
    using LastInstrMap = ordered_map<PHV::FieldSlice, const IR::MAU::Instruction *>;
    ordered_map<const IR::MAU::Action *, LastInstrMap> last_instr_per_action_map;
    // Store field and all its phv bits in current action. Used for handling overlapping set
    ordered_map<const PHV::Field *, safe_vector<le_bitrange>> fs_bits;
    // Need to handle overlapping set if it's set to true.
    ordered_map<const PHV::Field *, bool> has_overlap_set;
 
 private:
    class Scan : public MauInspector, TofinoWriteContext {
        EliminateAllButLastWrite &self;
        LastInstrMap last_instr_map;
 
        bool preorder(const IR::MAU::Action *) override;
        bool preorder(const IR::MAU::Instruction *) override;
        bool preorder(const IR::MAU::StatefulCall *) override { return false; }
        bool preorder(const IR::MAU::BackendAttached *) override { return false; }
        void postorder(const IR::MAU::Action *) override;
 
     public:
        explicit Scan(EliminateAllButLastWrite &self) : self(self) {}
    };
 
    class Update : public MauTransform, TofinoWriteContext {
        EliminateAllButLastWrite &self;
        const IR::MAU::Action *current_af = nullptr;
        const IR::MAU::Action *preorder(IR::MAU::Action *) override;
        const IR::Node *preorder(IR::MAU::Instruction *) override;
        const IR::MAU::StatefulCall *preorder(IR::MAU::StatefulCall *sc) override {
            prune();
            return sc;
        }
        const IR::MAU::BackendAttached *preorder(IR::MAU::BackendAttached *ba) override {
            prune();
            return ba;
        }
 
     public:
        explicit Update(EliminateAllButLastWrite &self) : self(self) {}
    };
 
 public:
    explicit EliminateAllButLastWrite(const PhvInfo &p) : phv(p) {
        addPasses({new Scan(*this), new Update(*this)});
    }
};
 
class ArithCompareAdjustment : public PassManager {
    const PhvInfo &phv;
 
 public:
    std::map<const PHV::Field *, int> comp_adj_field_width_map;
    std::map<const cstring, int> comp_adj_name_width_map;
    std::map<const IR::MAU::Action *, std::set<const PHV::Field *>> comp_adj_fields_per_action_map;
 
 private:
    class Scan : public MauInspector {
        ArithCompareAdjustment &self;
        std::map<const PHV::Field *, bitvec> comp_or_set_zero_writes;
        ordered_map<const PHV::Field *, int> comp_targets;
        std::set<const PHV::Field *> other_targets;
 
        bool preorder(const IR::MAU::Action *) override;
        bool preorder(const IR::MAU::Instruction *) override;
        bool preorder(const IR::MAU::StatefulCall *) override { return false; }
        bool preorder(const IR::MAU::BackendAttached *) override { return false; }
        void postorder(const IR::MAU::Action *) override;
 
     public:
        explicit Scan(ArithCompareAdjustment &self) : self(self) {}
    };
 
    class Update : public Transform {
     private:
        ArithCompareAdjustment &self;
        const IR::MAU::Action *current_af = nullptr;
        std::set<const PHV::Field *> comp_adj_fields;
 
        const IR::MAU::Action *preorder(IR::MAU::Action *) override;
        const IR::MAU::Instruction *preorder(IR::MAU::Instruction *) override;
        const IR::Metadata *preorder(IR::Metadata *) override;
        const IR::ConcreteHeaderRef *preorder(IR::ConcreteHeaderRef *) override;
        const IR::Node *preorder(IR::Member *) override;
        const IR::Type_StructLike *adjust_type_struct(const IR::Type_StructLike *, cstring name);
        const IR::MAU::StatefulCall *preorder(IR::MAU::StatefulCall *sc) override {
            prune();
            return sc;
        }
        const IR::MAU::BackendAttached *preorder(IR::MAU::BackendAttached *ba) override {
            prune();
            return ba;
        }
        const IR::MAU::Action *postorder(IR::MAU::Action *) override;
 
     public:
        explicit Update(ArithCompareAdjustment &self) : self(self) {}
    };
 
    bool is_compare(cstring name) {
        return name == "gtequ" || name == "gteqs" || name == "ltu" || name == "lts" ||
               name == "lequ" || name == "leqs" || name == "gtu" || name == "gts" || name == "eq" ||
               name == "neq" || name == "eq64" || name == "neq64";
    }
 
 public:
    explicit ArithCompareAdjustment(const PhvInfo &p) : phv(p) {
        addPasses({new Scan(*this), new Update(*this)});
    }
};
 
class MeterSetup : public PassManager {
    // Tracks the inputs per lpf
    ordered_map<const IR::MAU::Meter *, const IR::Expression *> update_lpfs;
    // Tracks the pre-color per meter
    ordered_map<const IR::MAU::Meter *, const IR::Expression *> update_pre_colors;
    // Marks an action for setting a meter type
    ordered_map<const IR::MAU::Action *, UniqueAttachedId> pre_color_types;
    ordered_map<const IR::MAU::Action *, UniqueAttachedId> standard_types;
    const PhvInfo &phv;
 
    class Scan : public MauInspector {
        MeterSetup &self;
        void find_input(const IR::MAU::Primitive *);
        void find_pre_color(const IR::MAU::Primitive *);
        const IR::Expression *convert_cast_to_slice(const IR::Expression *);
        profile_t init_apply(const IR::Node *root) override;
        bool preorder(const IR::MAU::Instruction *) override;
        bool preorder(const IR::MAU::Primitive *) override;
 
     public:
        explicit Scan(MeterSetup &self) : self(self) {}
    };
 
    class Update : public MauModifier {
        MeterSetup &self;
        void update_input(IR::MAU::Meter *);
        void update_pre_color(IR::MAU::Meter *);
        bool preorder(IR::MAU::Meter *) override;
        bool preorder(IR::MAU::Action *) override;
 
     public:
        explicit Update(MeterSetup &self) : self(self) {}
    };
 
 public:
    explicit MeterSetup(const PhvInfo &p) : phv(p) {
        addPasses({new Scan(*this), new Update(*this)});
    }
};
 
class SetupAttachedAddressing : public PassManager {
    struct AttachedActionCoord {
        bool all_per_flow_enabled = true;
        bool all_same_meter_type = true;
        bool meter_type_set = false;
        IR::MAU::MeterType meter_type = IR::MAU::MeterType::UNUSED;
        const IR::MAU::AttachedMemory *am = nullptr;
    };
 
    using AttachedInfo = std::map<UniqueAttachedId, AttachedActionCoord>;
    // coordinate the Attached Info across all inspectors
    ordered_map<const IR::MAU::Table *, AttachedInfo> all_attached_info;
    // Just to run the modifier on BackendAttached Objects
    ordered_map<const IR::MAU::BackendAttached *, AttachedActionCoord> attached_coord;
 
    class InitializeAttachedInfo : public MauInspector {
        SetupAttachedAddressing &self;
        bool preorder(const IR::MAU::BackendAttached *) override;
 
     public:
        explicit InitializeAttachedInfo(SetupAttachedAddressing &self) : self(self) {}
    };
 
    class ScanTables : public MauInspector {
        SetupAttachedAddressing &self;
        bool preorder(const IR::MAU::Table *) override;
 
     public:
        explicit ScanTables(SetupAttachedAddressing &self) : self(self) {}
    };
 
    class VerifyAttached : public MauInspector {
        SetupAttachedAddressing &self;
        bool preorder(const IR::MAU::BackendAttached *) override;
 
     public:
        explicit VerifyAttached(SetupAttachedAddressing &self) : self(self) {}
    };
 
    class UpdateAttached : public MauModifier {
        SetupAttachedAddressing &self;
        void simple_attached(IR::MAU::BackendAttached *);
        bool preorder(IR::MAU::BackendAttached *) override;
 
     public:
        explicit UpdateAttached(SetupAttachedAddressing &self) : self(self) {}
    };
 
 public:
    SetupAttachedAddressing() {
        addPasses({new InitializeAttachedInfo(*this), new ScanTables(*this),
                   new VerifyAttached(*this), new UpdateAttached(*this)});
    }
};
 
class RemoveUnnecessaryActionArgSlice : public MauTransform {
    const IR::Node *preorder(IR::Slice *) override;
 
 public:
    RemoveUnnecessaryActionArgSlice() {}
};
 
class GuaranteeHashDistSize : public PassManager {
    ordered_set<const IR::MAU::Instruction *> hash_dist_instrs;
 
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = PassManager::init_apply(node);
        hash_dist_instrs.clear();
        return rv;
    }
 
    class Scan : public MauInspector {
        GuaranteeHashDistSize &self;
        bool contains_hash_dist = false;
 
        bool preorder(const IR::MAU::BackendAttached *) override { return false; }
        bool preorder(const IR::MAU::StatefulCall *) override { return false; }
        bool preorder(const IR::MAU::Instruction *) override;
        bool preorder(const IR::MAU::HashDist *) override;
        void postorder(const IR::MAU::Instruction *) override;
 
     public:
        explicit Scan(GuaranteeHashDistSize &s) : self(s) {}
    };
 
    class Update : public MauTransform {
        GuaranteeHashDistSize &self;
 
        const IR::Node *postorder(IR::MAU::Instruction *) override;
 
     public:
        explicit Update(GuaranteeHashDistSize &s) : self(s) {}
    };
 
 public:
    GuaranteeHashDistSize() { addPasses({new Scan(*this), new Update(*this)}); }
};
 
class SimplifyConditionalActionArg : public MauTransform {
 public:
    SimplifyConditionalActionArg() {}
    const IR::Node *postorder(IR::Mux *prim) override;
};
 
class InstructionSelection : public PassManager {
 public:
    InstructionSelection(const BFN_Options &, PhvInfo &, const ReductionOrInfo &);
};
 
#endif /* BF_P4C_MAU_INSTRUCTION_SELECTION_H_ */