slicing/types.h

 
#ifndef BF_P4C_PHV_SLICING_TYPES_H_
#define BF_P4C_PHV_SLICING_TYPES_H_
 
#include <functional>
 
#include "bf-p4c/ir/bitrange.h"
#include "bf-p4c/phv/utils/utils.h"
#include "lib/bitvec.h"
#include "lib/ordered_map.h"
 
namespace PHV {
namespace Slicing {
 
using IterateCb = std::function<bool(std::list<SuperCluster *>)>;
 
using PHVContainerSizeLayout = ordered_map<const PHV::Field *, std::vector<int>>;
 
using PackConflictChecker = std::function<bool(const FieldSlice &fs1, const FieldSlice &fs2)>;
 
using IsReferencedChecker = std::function<bool(const Field *f1)>;
 
struct IteratorConfig {
    bool minimal_packing_mode = false;
 
    bool loose_action_packing_check_mode = false;
 
    bool smart_backtracking_mode = false;
 
    bool smart_slicing = true;
 
    bool homogeneous_slicing = false;
 
    int max_search_steps = (1 << 25);
 
    int max_search_steps_per_solution = (1 << 16);
 
    bool disable_packing_check = false;
 
    IteratorConfig(bool minimal_packing_mode, bool loose_action_packing_check_mode,
                   bool smart_backtracking_mode, bool smart_slicing, bool same_slices,
                   int max_search_steps, int max_search_steps_per_solution)
        : minimal_packing_mode(minimal_packing_mode),
          loose_action_packing_check_mode(loose_action_packing_check_mode),
          smart_backtracking_mode(smart_backtracking_mode),
          smart_slicing(smart_slicing),
          homogeneous_slicing(same_slices),
          max_search_steps(max_search_steps),
          max_search_steps_per_solution(max_search_steps_per_solution) {}
};
 
class IteratorInterface {
 public:
    virtual void iterate(const IterateCb &cb) = 0;
 
    virtual void invalidate(const SuperCluster::SliceList *sl) = 0;
 
    virtual void set_config(const IteratorConfig &cfg) = 0;
};
 
}  // namespace Slicing
}  // namespace PHV
 
#endif /* BF_P4C_PHV_SLICING_TYPES_H_ */