instruction_memory.h

 
#ifndef BF_P4C_MAU_INSTRUCTION_MEMORY_H_
#define BF_P4C_MAU_INSTRUCTION_MEMORY_H_
 
/* clang-format off */
#include "bf-p4c/mau/table_layout.h"
#include "bf-p4c/ir/gress.h"
#include "bf-p4c/common/alloc.h"
 
using namespace P4;
 
class GenerateVLIWInstructions {
    PhvInfo &phv;
    ActionData::FormatType_t format_type;
    SplitAttachedInfo &split_attached;
    const IR::MAU::Table* tbl;
 
    void generate_for_action(const IR::MAU::Action *);
    ordered_map<const IR::MAU::Action *, bitvec> table_instrs;
    ordered_map<const IR::MAU::Action *, bool> table_instrs_has_unalloc_tempvar;
 
 public:
    bitvec get_instr(const IR::MAU::Action *act) {
        return table_instrs[act];
    }
    bool instr_has_unalloc_tempvar(const IR::MAU::Action *act) {
        return table_instrs_has_unalloc_tempvar[act];
    }
    GenerateVLIWInstructions(PhvInfo &p, ActionData::FormatType_t ft,
            SplitAttachedInfo &sai, const IR::MAU::Table* tbl);
};
 
struct InstructionMemory {
    static constexpr int NOOP_ROW = 0;
    static constexpr int NOOP_COLOR = 0;
    const IMemSpec &spec;
 
 protected:
    explicit InstructionMemory(const IMemSpec &s) : spec(s) {}
 
    InstructionMemory(const InstructionMemory &) = delete;
    InstructionMemory &operator=(const InstructionMemory &) = delete;
 
 public:
    virtual ~InstructionMemory() = default;
 
    std::set<cstring> atcam_updates;
 
    struct Use {
        struct VLIW_Instruction {
            bitvec non_noop_instructions;
            int row;
            int color;
            int mem_code = -1;
 
            // The address for the RAM line is in this format
            unsigned gen_addr() const {
                return color | row << Device::imemSpec().color_bits();
            }
            VLIW_Instruction(bitvec nni, int r, int c)
                : non_noop_instructions(nni), row(r), color(c) {}
 
            bool operator==(const VLIW_Instruction &v) const {
                return (non_noop_instructions == v.non_noop_instructions) && \
                       (row == v.row) && \
                       (color == v.color) && \
                       (mem_code == v.mem_code);
            }
 
            friend std::ostream & operator<<(std::ostream &out, const VLIW_Instruction &i);
        };
        std::map<cstring, VLIW_Instruction> all_instrs;
 
        void clear() {
            all_instrs.clear();
        }
        void merge(const Use &alloc);
 
        bool operator==(const Use &u) const {
            return all_instrs == u.all_instrs;
        }
 
        bool operator!=(const Use &u) const {
            return all_instrs != u.all_instrs;
        }
 
        friend std::ostream & operator<<(std::ostream &out, const Use &u);
    };
 
    std::map<const IR::MAU::ActionData *, const Use *> shared_action_profiles;
        // std::map<cstring, InstructionMemory::Use::VLIW_Instruction>> shared_action_profiles;
 
    virtual BFN::Alloc2Dbase<cstring> &imem_use(gress_t gress) = 0;
    const BFN::Alloc2Dbase<cstring> &imem_use(gress_t gress) const {
        return const_cast<InstructionMemory *>(this)->imem_use(gress); }
    virtual BFN::Alloc2Dbase<bitvec> &imem_slot_inuse(gress_t gress) = 0;
    const BFN::Alloc2Dbase<bitvec> &imem_slot_inuse(gress_t gress) const {
        return const_cast<InstructionMemory *>(this)->imem_slot_inuse(gress); }
 
    bool is_noop_slot(int row, int color);
    bool find_row_and_color(bitvec current_bv, gress_t gress, int &row, int &color,
                            bool &first_noop, bool has_unalloc_temp = false);
    bool shared_instr(const IR::MAU::Table *tbl, Use &alloc, bool gw_linked);
    bool alloc_always_run_instr(const IR::MAU::Table *tbl, Use &alloc, bitvec current_bv);
 
 public:
    bool allocate_imem(const IR::MAU::Table *tbl, Use &alloc, PhvInfo &phv, bool gw_linked,
        ActionData::FormatType_t format_type, SplitAttachedInfo &sai);
    void update_always_run(const Use &alloc, gress_t gress);
    void update(cstring name, const Use &alloc, gress_t gress);
    void update(cstring name, const TableResourceAlloc *alloc, gress_t gress);
    void update(cstring name, const TableResourceAlloc *alloc, const IR::MAU::Table *tbl);
    void update(const IR::MAU::Table *tbl);
 
    static InstructionMemory *create();
};
 
/* clang-format on */
 
#endif /* BF_P4C_MAU_INSTRUCTION_MEMORY_H_ */