 |
P4C
The P4 Compiler
|
|
P4C
The P4 Compiler
|
#include <instruction_adjustment.h>
Public Member Functions | |
| SplitInstructions (const PhvInfo &p) | |
 Public Member Functions inherited from P4::Transform | |
| const IR::Node * | apply_visitor (const IR::Node *, const char *name=0) override |
| profile_t | init_apply (const IR::Node *root) override |
| virtual void | loop_revisit (const IR::Node *) |
| virtual const IR::Node * | postorder (IR::Node *n) |
| virtual const IR::Node * | preorder (IR::Node *n) |
| void | prune () |
| virtual void | revisit (const IR::Node *, const IR::Node *) |
| void | revisit_visited () |
| bool | visit_in_progress (const IR::Node *) const |
| void | visitAgain () const override |
| void | visitOnce () const override |
| Public Member Functions inherited from P4::Visitor | |
| virtual bool | check_global (cstring) |
| virtual void | clear_globals () |
| virtual Visitor * | clone () const |
| virtual ControlFlowVisitor * | controlFlowVisitor () |
| virtual void | end_apply () |
| virtual void | end_apply (const IR::Node *root) |
| virtual void | erase_global (cstring) |
| template<class T > | |
| const T * | findContext () const |
| template<class T > | |
| const T * | findContext (const Context *&c) const |
| template<class T > | |
| const T * | findOrigCtxt () const |
| template<class T > | |
| const T * | findOrigCtxt (const Context *&c) const |
| virtual Visitor & | flow_clone () |
| virtual void | flow_merge (Visitor &) |
| virtual bool | flow_merge_closure (Visitor &) |
| virtual void | flow_merge_global_from (cstring) |
| virtual void | flow_merge_global_to (cstring) |
| const Context * | getChildContext () const |
| int | getChildrenVisited () const |
| const Context * | getContext () const |
| int | getContextDepth () const |
| const IR::Node * | getCurrentNode () const |
| template<class T > | |
| const T * | getCurrentNode () const |
| const IR::Node * | getOriginal () const |
| template<class T > | |
| const T * | getOriginal () const |
| template<class T > | |
| const T * | getParent () const |
| virtual bool | has_flow_joins () const |
| profile_t | init_apply (const IR::Node *root, const Context *parent_context) |
| bool | isInContext (const IR::Node *n) const |
| virtual const char * | name () const |
| template<class T > | |
| void | parallel_visit (const IR::Vector< T > &v, const char *name, int cidx) |
| template<class T > | |
| void | parallel_visit (const IR::Vector< T > &v, const char *name=0) |
| template<class T > | |
| void | parallel_visit (IR::Vector< T > &v, const char *name, int cidx) |
| template<class T > | |
| void | parallel_visit (IR::Vector< T > &v, const char *name=0) |
| void | print_context () const |
| const Visitor & | setCalledBy (const Visitor *visitor) |
| void | setName (const char *name) |
| void | visit (const IR::Node &n, const char *name, int cidx) |
| void | visit (const IR::Node &n, const char *name=0) |
| void | visit (const IR::Node *&n, const char *name, int cidx) |
| void | visit (const IR::Node *&n, const char *name=0) |
| void | visit (const IR::Node *const &n, const char *name, int cidx) |
| void | visit (const IR::Node *const &n, const char *name=0) |
| void | visit (IR::Node &n, const char *name, int cidx) |
| void | visit (IR::Node &n, const char *name=0) |
| void | visit (IR::Node *&, const char *=0, int=0) |
| template<class T , typename = std::enable_if_t<Util::has_SourceInfo_v<T> && !std::is_pointer_v<T>>, class... Args> | |
| void | warn (const int kind, const char *format, const T &node, Args &&...args) |
| The const ref variant of the above. | |
| template<class T , typename = std::enable_if_t<Util::has_SourceInfo_v<T>>, class... Args> | |
| void | warn (const int kind, const char *format, const T *node, Args &&...args) |
| bool | warning_enabled (int warning_kind) const |
Additional Inherited Members | |
| Public Types inherited from P4::Visitor | |
| typedef Visitor_Context | Context |
| Static Public Member Functions inherited from P4::Visitor | |
| static cstring | demangle (const char *) |
| static bool | warning_enabled (const Visitor *visitor, int warning_kind) |
| Public Attributes inherited from P4::Visitor | |
| const Visitor * | called_by = nullptr |
| cstring | internalName |
| SplitFlowVisit_base *& | split_link |
| SplitFlowVisit_base * | split_link_mem = nullptr |
| Protected Member Functions inherited from P4::Transform | |
| const IR::Node * | transform_child (const IR::Node *child) |
| Protected Member Functions inherited from P4::Visitor | |
| virtual void | init_join_flows (const IR::Node *) |
| virtual bool | join_flows (const IR::Node *) |
| virtual void | post_join_flows (const IR::Node *, const IR::Node *) |
| void | visit_children (const IR::Node *, std::function< void()> fn) |
| Protected Attributes inherited from P4::Transform | |
| bool | forceClone = false |
| Protected Attributes inherited from P4::Visitor | |
| bool | dontForwardChildrenBeforePreorder = false |
| bool | joinFlows = false |
| bool | visitDagOnce = true |
The purpose of these classes is to adjust the instructions in a single action that perform on multiple containers into one single action for the entire container. The pass also verifies that many Tofino specific constraints for the individual ALUs either through the PHVs being adapted or the action data being manipulated.
The adjustment specificially is from a field to field instruction into a container by container instruction for the more complex requirements. This either can break an field by field instruction into multiple container instructions, performed by SplitInstructions, or combine them into a single one, performed by MergeInstructions.
For example, the instructions before this pass look like the following: -set header.field1, header.field2 -set header.field3, header.field4 -set header.field5, action_data_param
In these instructions, there is only one field written to, and up to two fields read from, in i.e. a bit or an arithmetic operation. However, if header.field1 and header.field3 were in the same PHV container, the assembler does not understand multiple instruction calls on the same container, and would fail. Thus this pass would remove these instruction, and in their place put the names of the PHV containers instead, along the lines of: -set W1(0..23), W5(8..31)
Another major case is the splitting of fields. Say header.field5 is in multiple containers. The action_data_param may not come into the ALUs contiguously, and thus must be broken into instruction based on the allocation within the containers: -set header.field5.0-31 action_data_param.0-31 -set header.field5.32-47 action_data_param.32-47
In particular, some constants have to be converted to action data, based on how they are use in an instruction within a container. These constraints are fully detailed by comments in action_analysis, but are summarized by the restrictions from load const and one of the sources of an action Responsible for splitting all field instructions over multiple containers into multiple field instructions over a single container, for example, let's say the program has the following field instruction: -set hdr.f1, hdr.f2
where hdr.f1 is in two PHV containers. This will split this into
-set hdr.f1(A..B), hdr.f2(A..B) -set hdr.f1(C..D), hdr.f2(C..D)
where A..B and C..D are the write ranges of f1 within its associated container
1.12.0