fieldslice_live_range.h

 
#ifndef BACKENDS_TOFINO_BF_P4C_PHV_FIELDSLICE_LIVE_RANGE_H_
#define BACKENDS_TOFINO_BF_P4C_PHV_FIELDSLICE_LIVE_RANGE_H_
 
#include <algorithm>
 
#include "bf-p4c/common/field_defuse.h"
#include "bf-p4c/common/map_tables_to_actions.h"
#include "bf-p4c/mau/action_analysis.h"
#include "bf-p4c/parde/clot/clot_info.h"
#include "bf-p4c/phv/phv.h"
#include "bf-p4c/phv/pragma/phv_pragmas.h"
#include "lib/safe_vector.h"
#include "mau_backtracker.h"
 
namespace PHV {
 
class LiveRangeInfo {
 public:
    // OpInfo represents the `liveness requirement` of a fieldslice of a stage (including PARDE).
    // DEAD:       fieldslice does not need to be allocated.
    // READ:       fieldslice needs to be allocated before VLIW.
    // WRITE:      fieldslice needs to be allocated after VLIW.
    // READ_WRITE: fieldslice needs to be allocated before and after VLIW,
    //             (could have different containers for read and write)
    // LIVE:       fieldslice needs to be allocated before and after stage.
    //             (must be the same container)
    // Note that LIVE and READ_WRITE have almost the same `liveness requirement`, they are
    // different only when we compute disjoint live ranges, where READ_WRITE could be
    // a start of a new live range (changing container) but LIVE does not.
    // Consider two paired-defuse examples,
    // f1's paired defuse(s): [-1W, 0R], [0W, 2R] // will produce [-1W, 0RW, 1L, 2R]
    // f2's paired defuse(s): [-1, 2R]            // will produce [-1W, 0L, 1L, 2R]
    // f1 have two disjoint live ranges and they can be allocated to different containers
    // but f2 has to be allocated into one container.
    enum class OpInfo { DEAD, READ, WRITE, READ_WRITE, LIVE };
 
 private:
    static int num_table_stages;
 
    // -1 = parser
    // 0..num_table_stages - 1 = physical MAU stages
    // num_table_stages = deparser
    // we merge all together because we need to uniformly iterate
    // parser + mau + deparser.
    safe_vector<OpInfo> lives_i;
 
 public:
    LiveRangeInfo() {
        // Static variable can't be initialized to Device::numStages() as the device isn't known at
        // initialization time. Instead, check here that it's been set to a positive value.
        if (num_table_stages <= 0) num_table_stages = Device::numStages();
        lives_i.resize(num_table_stages + 2, OpInfo::DEAD);
    }
    OpInfo &parser() { return lives_i[0]; }
    const OpInfo &parser() const { return lives_i[0]; }
    OpInfo &deparser() { return lives_i[num_table_stages + 1]; }
    const OpInfo &deparser() const { return lives_i[num_table_stages + 1]; }
    OpInfo &stage(int i) { return lives_i[i + 1]; }
    const OpInfo &stage(int i) const { return lives_i[i + 1]; }
 
    static void set_num_table_stages(int stage) {
        num_table_stages = std::max(stage, Device::numStages());
    }
 
    const safe_vector<OpInfo> &vec() const { return lives_i; }
 
    bool can_overlay(const LiveRangeInfo &other) const;
 
    std::vector<LiveRange> disjoint_ranges() const;
 
    static std::vector<LiveRange> merge_invalid_ranges(const std::vector<LiveRange> &ranges);
};
 
LiveRangeInfo::OpInfo operator|(const LiveRangeInfo::OpInfo &, const LiveRangeInfo::OpInfo &);
LiveRangeInfo::OpInfo &operator|=(LiveRangeInfo::OpInfo &, const LiveRangeInfo::OpInfo &);
 
std::ostream &operator<<(std::ostream &out, const LiveRangeInfo::OpInfo &opinfo);
std::ostream &operator<<(std::ostream &out, const LiveRangeInfo &lr);
 
class IFieldSliceLiveRangeDB {
 public:
    virtual const LiveRangeInfo *get_liverange(const PHV::FieldSlice &) const = 0;
    virtual const LiveRangeInfo *default_liverange() const = 0;
};
 
class FieldSliceLiveRangeDB : public IFieldSliceLiveRangeDB, public PassManager {
    class MapFieldSliceToAction : public Inspector {
        const PhvInfo &phv;
        const ReductionOrInfo &red_info;
        Visitor::profile_t init_apply(const IR::Node *root) override;
 
     public:
        ordered_map<const IR::MAU::Action *, ordered_set<PHV::FieldSlice>> action_to_writes;
 
        ordered_map<const IR::MAU::Action *, ordered_set<PHV::FieldSlice>> action_to_reads;
 
        bool preorder(const IR::MAU::Action *act) override;
        MapFieldSliceToAction(const PhvInfo &phv, const ReductionOrInfo &ri)
            : phv(phv), red_info(ri) {}
    };
 
    class DBSetter : public Inspector {
        struct Location {
            enum unit { PARSER, TABLE, DEPARSER };
            unit u;
            ordered_set<int> stages;
        };
        const PhvInfo &phv;
        const ClotInfo &clot;
        const MauBacktracker *backtracker;
        const FieldDefUse *defuse;
        const MapFieldSliceToAction *fs_action_map;
        FieldSliceLiveRangeDB &self;
        const PHV::Pragmas &pragmas;
 
        std::optional<Location> to_location(const PHV::Field *field,
                                            const FieldDefUse::locpair &loc, bool is_read) const;
 
        std::pair<int, int> update_live_status(LiveRangeInfo &liverange, const Location &loc,
                                               bool is_read) const;
 
        void update_live_range_info(const PHV::FieldSlice &fs, const Location &use_loc,
                                    const Location &def_loc, LiveRangeInfo &liverange) const;
 
        const ordered_set<const PHV::Field *> &not_implicit_init_fields() const {
            return pragmas.pa_no_init().getFields();
        }
 
        void end_apply() override;
 
     public:
        DBSetter(const PhvInfo &phv, const ClotInfo &clot, const MauBacktracker *backtracker,
                 const FieldDefUse *defuse, const MapFieldSliceToAction *fs_action_map,
                 FieldSliceLiveRangeDB &self, const PHV::Pragmas &pragmas)
            : phv(phv),
              clot(clot),
              backtracker(backtracker),
              defuse(defuse),
              fs_action_map(fs_action_map),
              self(self),
              pragmas(pragmas) {}
    };
 
    const PHV::Pragmas &pragmas;
    MapFieldSliceToAction *fs_action_map;
    DBSetter *setter;
 
    ordered_map<const PHV::Field *, ordered_map<PHV::FieldSlice, LiveRangeInfo>> live_range_map;
    Visitor::profile_t init_apply(const IR::Node *root) override;
 
    void set_liverange(const PHV::FieldSlice &, const LiveRangeInfo &);
 
 public:
    FieldSliceLiveRangeDB(const MauBacktracker *backtracker, const FieldDefUse *defuse,
                          const PhvInfo &phv, const ReductionOrInfo &red_info, const ClotInfo &clot,
                          const PHV::Pragmas &pragmas)
        : pragmas(pragmas) {
        fs_action_map = new MapFieldSliceToAction(phv, red_info);
        setter = new DBSetter(phv, clot, backtracker, defuse, fs_action_map, *this, pragmas);
        addPasses({fs_action_map, setter});
    }
    const LiveRangeInfo *get_liverange(const PHV::FieldSlice &) const override;
    const LiveRangeInfo *default_liverange() const override;
};
 
}  // namespace PHV
 
#endif /* BACKENDS_TOFINO_BF_P4C_PHV_FIELDSLICE_LIVE_RANGE_H_ */