def __init__(self, name, actions, action_info):
def findActionInfo(action_info, action):
for at in action_info:
if at['name'] == action[1]:
return at
self.name = name
elements = []
atype = "%sActionT" %(CamelCase(name))
elements.append(ast.EnumElement("DEFAULT_%s"%(name.upper()), "", 0))
for idx, at in enumerate(actions):
elements.append(ast.EnumElement(at.lstrip('_').upper(), "", idx))
self.enum = ast.Enum(atype, elements)
fields = []
field_set = set()
fields.append(ast.StructMember(atype, "_action"))
dwidth = 0
for at in enumerate(actions):
info = findActionInfo(action_info, at)
runtime_data = info['runtime_data']
for data in runtime_data:
data_width = data['bitwidth']
data_name = "runtime_%s"%(data['name'])
if data_name not in field_set:
fields.append(ast.StructMember("Bit#(%s)" %(data_width), data_name))
field_set.add(data_name)
dwidth += data_width
self.struct = ast.Struct("%sRspT"%(CamelCase(self.name)), fields)
self.width = int(math.ceil(math.log(len(actions) + 1, 2))) + dwidth
def __init__(self, name, members, runtime_data=[], bypass_map=None):
self.name = name
self.members = members
self.runtime_data = runtime_data
self.bypass_map = bypass_map
e = []
e.append(ast.StructMember("PacketInstance", "pkt"))
for m in members:
_m = p4name(m)
e.append(ast.StructMember("Bit#(%s)"%(GetFieldWidth(m)), _m))
for r in runtime_data:
e.append(ast.StructMember("Bit#(%s)"%(r[0]), "runtime_%s_%d"%(r[1], r[0])))
self.struct = ast.Struct(name, e)
def __init__(self, struct_attrs):
self.name = struct_attrs['name']
self.stmt = []
fields = struct_attrs['fields']
e = []
for f, l in fields:
if f[0].isupper():
f = f[0].lower() + f
e.append(ast.StructMember("Bit#(%s)"%(l), avoid_bsv_keyword(f)))
self.struct = ast.Struct(CamelCase(self.name), e)
self._add_defaults(fields)
def __init__(self, name, key):
self.name = name
fields = []
total_width = 0
pad_width = 0
for k in key:
if k['match_type'] == 'valid':
total_width += 1
name = 'valid_%s' % (k['target'].translate(None, "[]"))
fields.append(ast.StructMember("Bool", name))
else:
width = GetFieldWidth(k['target'])
total_width += width
name = p4name(k['target'])
fields.append(ast.StructMember("Bit#(%s)" %(width), name))
if (total_width % 9):
pad_width = 9 - total_width % 9
fields.insert(0, ast.StructMember("Bit#(%s)" %(pad_width), "padding"))
self.struct = ast.Struct("%sReqT"%(CamelCase(self.name)), fields)
self.width = total_width + pad_width
def render_runtime_types(ir, json_dict):
# metadata req/rsp
ir.structs['metadata_request'] = StructT("MetadataRequest")
ir.structs['metadata_response'] = StructT("MetadataResponse")
#responses = []
for pipeline in json_dict['pipelines']:
name = pipeline['name']
for t in sorted(pipeline['tables'], key=lambda k: k['name']):
responses = []
tname = t['name']
tnext = t['actions']
for n in tnext:
sname = "%s%sRspT" % (CamelCase(tname), CamelCase(n))
stmt = []
stmt.append(ast.StructMember("PacketInstance", "pkt"))
stmt.append(ast.StructMember("MetadataT", "meta"))
responses.append(ast.Struct(sname, stmt))
union_name = "%sResponse" % CamelCase(tname)
ir.structs[union_name] = ast.TypeDef("union tagged", union_name,
responses)
ir.structs['metadata'] = StructMetadata("MetadataT", ir)
def __init__(self, name, ir):
self.name = name
metadata = ir.global_metadata;
fields = []
for header, flds in metadata.items():
for f in flds:
name = "%s$%s" % (header, f[1])
fields.append(ast.StructMember("Maybe#(Bit#(%s))"%(f[0]), name))
avoid_bsv_keyword(f[1])
# valid fields
#for it in ir.parsers.values():
# for h in it.header_instances.values():
# name = "valid_%s" % (camelCase(h))
# fields.append(ast.StructMember("Maybe#(Bit#(0))", name))
self.struct = ast.Struct(self.name, fields)
def _build(self):
e = []
e.append(ast.StructMember("PacketInstance", "pkt"))
e.append(ast.StructMember("MetadataT", "meta"))
struct = ast.Struct(self.name, e)
return struct