#include <pa_byte_pack.h>

Inheritance diagram for PragmaBytePack:

Classes
struct	AddConstraintResult

struct	PackConstraint

Public Member Functions
	PragmaBytePack (PhvInfo &phv)

AddConstraintResult	add_compiler_added_packing (const PHV::PackingLayout &packing)

const safe_vector< PackConstraint > &	packings () const

Public Member Functions inherited from P4::Inspector
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 void	postorder (const IR::Node *)

virtual bool	preorder (const IR::Node *)

virtual void	revisit (const IR::Node *)

void	revisit_visited ()

bool	visit_in_progress (const IR::Node *n) 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

Static Public Attributes
static const char *	description

static const char *	help

static const char *	name = "pa_byte_pack"
	BFN::Pragma interface.

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::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::Visitor
bool	dontForwardChildrenBeforePreorder = false

bool	joinFlows = false

bool	visitDagOnce = true

Detailed Description

PragmaBytePack allows users and also other compiler passes to specify byte layouts of metadata for PHV allocation. The concept byte layout can be illustrated in the following example: Assume we have @pa_byte_pack(2, f1<4>, 1, f2<6>, f3<3>), (MSB to LSB) PHV allocation must allocate following 2 bytes to byte-aligned position of containers byte1: [f3, f2<6>[0:4]], byte2: [f2<6>[5:5], pad1<1>, f1<4>, pad0<2>] (LSB to MSB) Internally, we implement this feature by packing fields into a PHV::SuperCluster::SliceList and also updating their alignment constraint. Because alignments of PHV::FieldSlices are computed based on alignments of corresponding PHV::Field, this pass must run before creating PHV::FieldSlice (as of v9.8, it is the Clustering pass).

Class Documentation

◆ PragmaBytePack::PackConstraint

struct PragmaBytePack::PackConstraint

PackConstraint represents a packing constraints. If the constraint is added in the program compiler_added will be false and will have a non-null src_info.

Class Members
bool	compiler_added
PackingLayout	packing
optional< SourceInfo >	src_info

Member Function Documentation

◆ add_compiler_added_packing()

PragmaBytePack::AddConstraintResult PragmaBytePack::add_compiler_added_packing ( const PHV::PackingLayout & packing )

add additional pack constraints. NOTE: this function must be called before creating any PHV::FieldSlices because it might change alignment of PHV::Field. If alignment conflict was found,

Returns: std::nullopt, otherwise,; a set of fields with updated additional alignment constraint. NOTE: the order of packing (also for all PHV::PackingLayout instances) needs to be MSB to LSB.

◆ packings()

const safe_vector< PackConstraint > & PragmaBytePack::packings ( ) const

inline

Returns: all packing constraints saved.

Member Data Documentation

◆ description

const char * PragmaBytePack::description

static

Initial value:

=

"Force PHV allocation to allocate metadata fields in the specified layout."

◆ help

const char * PragmaBytePack::help

static

Initial value:

= R"(@pragma pa_byte_pack [pipe] gress ["field_name"|integer]+,
where field names refer to metadata or pov fields, and integers represent the number of bits as padding.
+ attached to P4 header instances.
 
For example, assume that f1 is 4-bit, f2 is 6-bit and f3 is 3-bit, and we have
@pa_byte_pack("ingress", 2, "f1", 1, "f2", "f3").
Then PHV allocation must allocate following 2 bytes to byte-aligned positions of containers.
byte1 = f2[4:0] ++ f3;
byte2 = 2w0 ++ f1 ++ 1w0 ++ f2[0:0];
One way to understand this pramga is to think of it as `making a pseudo header of metadata`, and
this header only introduces co-pack constraints within bytes, i.e., relative order between bytes
is not constrainted. For example, assume that byte1 and byte2 are allocated to one 16-bit
container H1, both H1 = byte1 ++ byte2 and H1 = byte2 ++ byte1 are valid.
 
This pragma is useful in tuning table placement and power consumption, by proposing
optimal packing layouts of metadata fields which are used as match keys.
 
*Constraints*
1. The total number of bits in all fields and padding must be divisible by 8.
2. Each padding element must be greater than 0 and less than 8 bits.
3. Fields used in this pragma must be metadata fields.
4. If a metadata or pov field is written in the parser, then the parser will also write to other
   fields packed in the same byte as the target field. Users of this pragma must either:
     <1> Never pack two parsed fields in the same byte.
     <2> Explicitly initialize non-parsed fields after the parser,
         even if @auto-init-metadata is enabled.
5. Compilation will fail if the pramga cannot be satisfied.)"

◆ name

const char * PragmaBytePack::name = "pa_byte_pack"

static

BFN::Pragma interface.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

SPDX-License-Identifier: Apache-2.0

Classes

Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Class Documentation

◆ PragmaBytePack::PackConstraint

Member Function Documentation

◆ add_compiler_added_packing()

◆ packings()

Member Data Documentation

◆ description

◆ help

◆ name