instruction_adjustment.h

 
#ifndef BF_P4C_MAU_INSTRUCTION_ADJUSTMENT_H_
#define BF_P4C_MAU_INSTRUCTION_ADJUSTMENT_H_
 
#include <fstream>
 
#include "bf-p4c/ir/tofino_write_context.h"
#include "bf-p4c/mau/action_analysis.h"
#include "bf-p4c/mau/mau_visitor.h"
#include "bf-p4c/mau/resource.h"
#include "bf-p4c/mau/tofino/input_xbar.h"
#include "bf-p4c/phv/phv.h"
#include "lib/safe_vector.h"
 
using namespace P4;
 
namespace PHV {
class Field;
}  // namespace PHV
 
class AdjustShiftInstructions : public MauTransform, TofinoWriteContext {
    const PhvInfo &phv;
 
    const IR::Node *preorder(IR::MAU::Instruction *) override;
    // ignore stuff related to stateful alus
    const IR::Node *preorder(IR::MAU::AttachedOutput *ao) override {
        prune();
        return ao;
    }
    const IR::Node *preorder(IR::MAU::StatefulAlu *salu) override {
        prune();
        return salu;
    }
    const IR::Node *preorder(IR::MAU::HashDist *hd) override {
        prune();
        return hd;
    }
 
 public:
    explicit AdjustShiftInstructions(const PhvInfo &p) : phv(p) {}
};
 
class SplitInstructions : public MauTransform, TofinoWriteContext {
    const PhvInfo &phv;
 
    const IR::Node *preorder(IR::MAU::Instruction *) override;
    // ignore stuff related to stateful alus
    const IR::Node *preorder(IR::MAU::AttachedOutput *ao) override {
        prune();
        return ao;
    }
    const IR::Node *preorder(IR::MAU::StatefulAlu *salu) override {
        prune();
        return salu;
    }
    const IR::Node *preorder(IR::MAU::HashDist *hd) override {
        prune();
        return hd;
    }
 
 public:
    explicit SplitInstructions(const PhvInfo &p) : phv(p) {}
};
 
class ConstantsToActionData : public MauTransform, TofinoWriteContext {
    const PhvInfo &phv;
    const ReductionOrInfo &red_info;
    ActionAnalysis::ContainerActionsMap container_actions_map;
 
    const IR::MAU::Action *preorder(IR::MAU::Action *) override;
    const IR::MAU::Instruction *preorder(IR::MAU::Instruction *) override;
    const IR::MAU::ActionArg *preorder(IR::MAU::ActionArg *) override;
    const IR::Expression *preorder(IR::Expression *) override;
    const IR::Constant *preorder(IR::Constant *) override;
    const IR::Slice *preorder(IR::Slice *) override;
    void analyze_phv_field(IR::Expression *);
    const IR::MAU::Primitive *preorder(IR::MAU::Primitive *) override;
    const IR::MAU::Instruction *postorder(IR::MAU::Instruction *) override;
    const IR::MAU::Action *postorder(IR::MAU::Action *) override;
 
    const IR::MAU::AttachedOutput *preorder(IR::MAU::AttachedOutput *) override;
    const IR::MAU::StatefulAlu *preorder(IR::MAU::StatefulAlu *) override;
    const IR::MAU::HashDist *preorder(IR::MAU::HashDist *) override;
    const IR::Node *preorder(IR::Node *) override;
    bool has_constant = false;
    bool write_found = false;
    ordered_set<PHV::Container> constant_containers;
    // ActionFormat::ArgKey constant_renames_key;
    ActionData::UniqueLocationKey constant_rename_key;
    cstring action_name;
 
 public:
    ConstantsToActionData(const PhvInfo &p, const ReductionOrInfo &ri) : phv(p), red_info(ri) {
        visitDagOnce = false;
    }
};
 
class ExpressionsToHash : public MauTransform {
    const PhvInfo &phv;
    const ReductionOrInfo &red_info;
    ActionAnalysis::ContainerActionsMap container_actions_map;
    ordered_set<PHV::Container> expr_to_hash_containers;
 
    const IR::MAU::Action *preorder(IR::MAU::Action *) override;
    const IR::MAU::Instruction *preorder(IR::MAU::Instruction *) override;
    const IR::Node *preorder(IR::Node *n) override {
        visitOnce();
        return n;
    }
    const IR::MAU::StatefulAlu *preorder(IR::MAU::StatefulAlu *s) override {
        prune();
        return s;
    }
 
 public:
    ExpressionsToHash(const PhvInfo &p, const ReductionOrInfo &ri) : phv(p), red_info(ri) {
        visitDagOnce = false;
    }
};
 
class MergeInstructions : public MauTransform, TofinoWriteContext {
 private:
    struct ByteRotateMergeInfo {
        int src1_shift = 0;
        int src2_shift = 0;
        bitvec src1_byte_mask;
    };
 
    bool saturationArith = false;
 
    const PhvInfo &phv;
    const ReductionOrInfo &red_info;
    ActionAnalysis::ContainerActionsMap container_actions_map;
 
    const IR::MAU::Action *preorder(IR::MAU::Action *) override;
    const IR::MAU::Instruction *preorder(IR::MAU::Instruction *) override;
    const IR::Expression *preorder(IR::Expression *) override;
    const IR::Slice *preorder(IR::Slice *) override;
    void analyze_phv_field(IR::Expression *);
    const IR::MAU::ActionDataConstant *preorder(IR::MAU::ActionDataConstant *) override;
    const IR::MAU::ActionArg *preorder(IR::MAU::ActionArg *) override;
    const IR::Constant *preorder(IR::Constant *) override;
    const IR::MAU::Primitive *preorder(IR::MAU::Primitive *) override;
 
    const IR::MAU::AttachedOutput *preorder(IR::MAU::AttachedOutput *ao) override;
    const IR::MAU::StatefulAlu *preorder(IR::MAU::StatefulAlu *salu) override;
    const IR::MAU::HashDist *preorder(IR::MAU::HashDist *hd) override;
 
    const IR::Node *preorder(IR::Node *) override;
    const IR::MAU::Instruction *postorder(IR::MAU::Instruction *) override;
    const IR::MAU::Action *postorder(IR::MAU::Action *) override;
 
    ordered_set<PHV::Container> merged_fields;
 
    bool write_found = false;
    ordered_set<PHV::Container>::iterator merged_location;
 
    IR::MAU::Instruction *dest_slice_to_container(PHV::Container container,
                                                  ActionAnalysis::ContainerAction &cont_action);
 
    void build_actiondata_source(ActionAnalysis::ContainerAction &cont_action,
                                 const IR::Expression **src1_p, bitvec &src1_writebits,
                                 ByteRotateMergeInfo &brm_info, PHV::Container container);
    void build_phv_source(ActionAnalysis::ContainerAction &cont_action,
                          const IR::Expression **src1_p, const IR::Expression **src2_p,
                          bitvec &src1_writebits, bitvec &src2_writebits,
                          ByteRotateMergeInfo &brm_info, PHV::Container container);
 
    IR::MAU::Instruction *build_merge_instruction(PHV::Container container,
                                                  ActionAnalysis::ContainerAction &cont_action);
    void fill_out_write_multi_operand(ActionAnalysis::ContainerAction &cont_action,
                                      IR::MAU::MultiOperand *mo);
    void fill_out_read_multi_operand(ActionAnalysis::ContainerAction &cont_action,
                                     ActionAnalysis::ActionParam::type_t type, cstring match_name,
                                     IR::MAU::MultiOperand *mo);
    const IR::Expression *fill_out_hash_operand(PHV::Container container,
                                                ActionAnalysis::ContainerAction &cont_action);
    const IR::Expression *fill_out_rand_operand(PHV::Container container,
                                                ActionAnalysis::ContainerAction &cont_action);
    const IR::Constant *find_field_action_constant(ActionAnalysis::ContainerAction &cont_action);
 
 public:
    MergeInstructions(const PhvInfo &p, const ReductionOrInfo &ri) : phv(p), red_info(ri) {
        visitDagOnce = false;
    }
};
 
class AdjustStatefulInstructions : public MauTransform {
 private:
    const PhvInfo &phv;
    const IR::Expression *preorder(IR::Expression *expr) override;
    const IR::Annotations *preorder(IR::Annotations *) override;
    const IR::MAU::IXBarExpression *preorder(IR::MAU::IXBarExpression *) override;
 
    bool check_bit_positions(std::map<int, le_bitrange> &salu_inputs, le_bitrange field_bits,
                             int starting_bit);
    bool verify_on_search_bus(const IR::MAU::StatefulAlu *, const Tofino::IXBar::Use &salu_ixbar,
                              const PHV::Field *field, le_bitrange &bits, bool &is_hi);
    bool verify_on_hash_bus(const IR::MAU::StatefulAlu *salu,
                            const Tofino::IXBar::Use::MeterAluHash &mah, const IR::Expression *expr,
                            le_bitrange &bits, bool &is_hi);
 
 public:
    explicit AdjustStatefulInstructions(const PhvInfo &p) : phv(p) {}
};
 
// Remove instructions which are effectively Noops in the code
// This class is when run post phv allocation can determine if an instruction is not performing an
// actual operation e.g. OR A, A, A / AND A, A, A
class EliminateNoopInstructions : public MauTransform {
 private:
    enum OP_TYPE { DST = 0, SRC1 = 1, SRC2 = 2 };
    const PhvInfo &phv;
    typedef std::set<std::pair<PHV::Container, le_bitrange>> AllocContainerSlice;
    bool get_alloc_slice(IR::MAU::Instruction *ins, OP_TYPE type,
                         AllocContainerSlice &op_alloc) const;
    const IR::MAU::Instruction *preorder(IR::MAU::Instruction *) override;
    const IR::MAU::Synth2Port *preorder(IR::MAU::Synth2Port *s) override;
    cstring toString(OP_TYPE ot) const {
        if (ot == DST)
            return "DST"_cs;
        else if (ot == SRC1)
            return "SRC1"_cs;
        else if (ot == SRC2)
            return "SRC2"_cs;
        return "-"_cs;
    }
 
 public:
    explicit EliminateNoopInstructions(const PhvInfo &p) : phv(p) {}
};
 
class InstructionAdjustment : public PassManager {
 public:
    InstructionAdjustment(const PhvInfo &p, const ReductionOrInfo &ri);
};
 
#endif /* BF_P4C_MAU_INSTRUCTION_ADJUSTMENT_H_ */