container_equivalence.h

 
#pragma once
 
#include "backends/tofino/bf-p4c/phv/utils/utils.h"
 
namespace PHV {
 
class ContainerEquivalenceTracker {
    using GressAssignment = PHV::Allocation::GressAssignment;
    using ExtractSource = PHV::Allocation::ExtractSource;
    using ContainerAllocStatus = PHV::Allocation::ContainerAllocStatus;
    enum class Parity : int8_t { Zero = 0, One = 1, Unspecified = -1 };
 
    struct ContainerClass {
        bool is_empty;
        Parity parity;
        PHV::Kind kind;
        GressAssignment gress;
        GressAssignment parser_group_gress;
        GressAssignment deparser_group_gress;
        ExtractSource parser_extract_group_source;
 
        ContainerClass(const PHV::Allocation &alloc, PHV::Container c, bool track_parity) {
            auto cstat = alloc.getStatus(c);
            BUG_CHECK(cstat, "no allocation status for container %1%", c);
            is_empty = cstat->alloc_status == ContainerAllocStatus::EMPTY;
            parity = track_parity ? Parity(c.index() % 2) : Parity::Unspecified;
            kind = c.type().kind();
            gress = cstat->gress;
            parser_group_gress = cstat->parserGroupGress;
            deparser_group_gress = cstat->deparserGroupGress;
            parser_extract_group_source = cstat->parserExtractGroupSource;
        }
 
        bool operator==(const ContainerClass &o) const { return as_tuple() == o.as_tuple(); }
 
        bool operator<(const ContainerClass &o) const { return as_tuple() < o.as_tuple(); }
 
        std::tuple<bool, Parity, PHV::Kind, GressAssignment, GressAssignment, GressAssignment,
                   ExtractSource>
        as_tuple() const {
            return std::make_tuple(is_empty, parity, kind, gress, parser_group_gress,
                                   deparser_group_gress, parser_extract_group_source);
        }
    };
 
 public:
    explicit ContainerEquivalenceTracker(const PHV::Allocation &alloc);
 
    std::optional<PHV::Container> find_equivalent_tried_container(PHV::Container c);
 
    void exclude(PHV::Container c) {
        if (c != PHV::Container()) excluded.insert(c);
    }
 
    void invalidate(PHV::Container c);
 
    void set_is_wide_arith() { wideArith = true; }
 
    void set_is_wide_arith_low() { wideArithLow = true; }
 
 private:
    std::optional<PHV::Container> find_single(PHV::Container);
    ContainerClass get_class(PHV::Container c) {
        return ContainerClass(alloc, c, wideArith || (restrictW0 && c.is(PHV::Size::b8)));
    }
 
    std::map<ContainerClass, PHV::Container> equivalenceClasses;
    std::set<PHV::Container> excluded;
    const PHV::Allocation &alloc;
    bool wideArith = false;
    bool wideArithLow = false;
    bool restrictW0;
};
 
}  // namespace PHV