action_data_bus.h

 
#ifndef BF_P4C_MAU_ACTION_DATA_BUS_H_
#define BF_P4C_MAU_ACTION_DATA_BUS_H_
 
#include "bf-p4c/mau/action_format.h"
#include "bf-p4c/mau/table_layout.h"
#include "lib/safe_vector.h"
 
using namespace P4;
 
struct ActionDataBus {
 public:
    struct Loc : public IHasDbPrint {
        int byte;
        ActionData::SlotType_t type;
        Loc(int b, ActionData::SlotType_t t) : byte(b), type(t) {}
        void dbprint(std::ostream &out) const {
            int slot_size = (8 << type);
            out << "ADB[" << byte << ":" << ((byte + slot_size / 8) - 1) << "]";
        }
        bool operator==(const Loc &loc) const {
            if (byte != loc.byte) return false;
            if (type != loc.type) return false;
            return true;
        };
        bool operator!=(const Loc &loc) const { return !(*this == loc); }
    };
    struct FullShare {
        bool full_in_use = false;
        unsigned shared_status = 0;
        int shared_byte[2] = {-1, -1};
        bool full_bitmasked_set = false;
        int full_bitmasked_index = -1;
        void init_full_bitmask(int fbi) {
            full_bitmasked_set = true;
            full_bitmasked_index = fbi;
        }
    };
 
    struct Use {
        struct ReservedSpace {
            Loc location;
            int byte_offset = -1;  
            bitvec bytes_used;     
            ActionData::Location_t source = ActionData::ALL_LOCATIONS;  
            ReservedSpace(Loc l, int bo, bitvec bu)
                : location(l), byte_offset(bo), bytes_used(bu) {}
            ReservedSpace(Loc l, int bo, bitvec bu, ActionData::Location_t src)
                : location(l), byte_offset(bo), bytes_used(bu), source(src) {}
            void dbprint(std::ostream &out) const {
                out << "Source:Offset " << source << ":" << byte_offset << " : " << location;
            }
            bool operator==(const ReservedSpace &rs) const {
                if (location != rs.location) return false;
                if (byte_offset != rs.byte_offset) return false;
                if (bytes_used != rs.bytes_used) return false;
                if (source != rs.source) return false;
                return true;
            }
            bool operator!=(const ReservedSpace &rs) const { return !(*this == rs); }
        };
        // Locations of action data where the ALUs will pull action data
        safe_vector<ReservedSpace> action_data_locs;
        // Slots reserved because unused action data was needed
        safe_vector<ReservedSpace> clobber_locs;
        virtual ~Use() {}
        virtual void clear() {
            action_data_locs.clear();
            clobber_locs.clear();
        }
        virtual Use *clone() const = 0;
        virtual bool emit_adb_asm(std::ostream &, const IR::MAU::Table *, bitvec source) const = 0;
        virtual bool empty() const { return action_data_locs.empty() && clobber_locs.empty(); }
        virtual int rng_unit() const = 0;
        bool operator==(const Use &use) const {
            if (action_data_locs != use.action_data_locs) return false;
            if (clobber_locs != use.clobber_locs) return false;
            return true;
        };
        bool operator!=(const Use &use) const { return !(*this == use); }
        friend std::ostream &operator<<(std::ostream &out, const Use &u);
    };
 
    enum loc_alg_t {
        FIND_NORMAL,
        FIND_LOWER,
        FIND_FULL,
        FIND_IMMED_UPPER,
        FIND_FULL_HALF,
        FIND_FULL_BYTE
    };
 
    virtual void clear();
 
 protected:
    // Holds information on already allocated ActionProfiles, Meters, and Stateful Alus
    ordered_map<const IR::MAU::AttachedMemory *, const Use &> allocated_attached;
    // Holds information on already allocated stateful ALUs in the same reduction or group
    ordered_map<cstring, const Use &> reduction_or_mapping;
 
 public:
    virtual ~ActionDataBus() {}
 
    virtual bool alloc_action_data_bus(const IR::MAU::Table *tbl,
                                       const ActionData::Format::Use *use,
                                       TableResourceAlloc &alloc) = 0;
    virtual bool alloc_action_data_bus(const IR::MAU::Table *tbl, const MeterALU::Format::Use *use,
                                       TableResourceAlloc &alloc) = 0;
    virtual void update(cstring name, const Use &alloc);
    virtual void update(cstring name, const Use::ReservedSpace &rs) = 0;
    virtual void update(const IR::MAU::Table *tbl);
    virtual void update(cstring name, const TableResourceAlloc *alloc, const IR::MAU::Table *tbl);
    virtual void update_action_data(cstring name, const TableResourceAlloc *alloc,
                                    const IR::MAU::Table *tbl);
    virtual void update_meter(cstring name, const TableResourceAlloc *alloc,
                              const IR::MAU::Table *tbl);
 
    static ActionDataBus *create();
    static int getAdbSize();
    friend std::ostream &operator<<(std::ostream &out, const ActionDataBus &adb);
};
 
#endif /* BF_P4C_MAU_ACTION_DATA_BUS_H_*/