def buildConditionalStmt(self, tblName, stmt, metadata=set()):
TMP1 = "MetadataRequest req = MetadataRequest {pkt: pkt, meta: meta};"
TMP2 = "%(name)s_req_ff.enq(req);"
toCurrPacketFifo = False
def search_conditional(name):
for key, cond in self.conditionals.items():
print key, cond
if key == name:
return cond
return None
if tblName is None:
stmt.append(
ast.Template(
"MetadataRequest req = MetadataRequest {pkt: pkt, meta: meta};"
))
stmt.append(ast.Template("next_req_ff.enq(req);"))
if tblName in self.tables:
stmt.append(ast.Template(TMP1))
stmt.append(ast.Template(TMP2, {"name": tblName}))
if tblName in self.conditionals:
cond = search_conditional(tblName)
expr = cond['expression'].replace("0x", "'h")
true_next = cond['true_next']
false_next = cond['false_next']
_meta = cond['metadata']
for m in _meta:
if type(m) is list:
metadata.add(tuple(m))
else:
metadata.add(m)
if true_next in self.tables:
_stmt = []
_stmt.append(ast.Template(TMP1,
{"name": CamelCase(true_next)}))
_stmt.append(ast.Template(TMP2, {"name": true_next}))
stmt.append(ast.If(expr, _stmt))
if true_next in self.conditionals:
_stmt = []
self.buildConditionalStmt(true_next, _stmt, metadata)
stmt.append(ast.If(expr, _stmt))
if false_next in self.tables:
_stmt = []
_stmt.append(
ast.Template(TMP1, {"name": CamelCase(false_next)}))
_stmt.append(ast.Template(TMP2, {"name": false_next}))
stmt.append(ast.Else(_stmt))
if false_next in self.conditionals:
_stmt = []
self.buildConditionalStmt(false_next, _stmt, metadata)
stmt.append(ast.Else(_stmt))
def build_rule_parse_done(self):
TMP1 = "let %(ktype)s <- toGet(%(ktype)s_out_ff).get;"
stmt = []
stmt += [ast.Template("MetadataT meta = defaultValue;")]
pdict = {}
pdict['ktype'] = set()
for idx, s in enumerate(self.states.values()):
keys = []
for k in s.transition_keys:
if k['type'] == 'lookahead':
print "WARNING: lookahead type not handled"
continue
keys.append("%s.%s" % (k['value'][0], k['value'][1]))
pdict['ktype'].add(k['value'][0])
pdict['field'] = ",".join(keys)
for ktype in pdict['ktype']:
stmt += [ast.Template(TMP1, {'ktype': ktype})]
for ktype in pdict['ktype']:
if ktype in self.metadata:
stmt_if = []
for f in self.metadata[ktype]:
stmt_if.append(ast.Template("meta.%(metafield)s = tagged Valid fromMaybe(?, %(ktype)s).%(field)s;" % {'metafield': "%s$%s" % (ktype, f[1]), 'ktype': ktype, 'field': f[1]}))
stmt += [ast.If("isValid(%s)" % ktype, stmt_if)]
stmt += [ast.Template("dbprint(3, $format(\"parse_done\"));")]
stmt += [ast.Template("meta_in_ff.enq(meta);")]
rcond = '(w_parse_done)' % pdict
rname = 'rl_parse_done' % pdict
rule = ast.Rule(rname, rcond, stmt, [])
return [rule]
def buildIfStmt(self, true=None, false=None):
_if = ast.If()
if true:
_if.stmt += self.buildIfStmt(true, false)
if false:
_if.stmt += self.buildIfStmt(true, false)
return _if
def build_rule_state_load(self, state):
tmpl = []
tmpl.append("data_ff.deq;")
tmpl.append("let data = zeroExtend(data_this_cycle) << rg_shift_amt[0] | rg_tmp[0];")
tmpl.append("rg_tmp[0] <= zeroExtend(data);")
tmpl.append("move_shift_amt(%d);" % (config.DP_WIDTH))
pdict = {}
pdict['name'] = state.name
pdict['CurrState'] = 'State%s' % (CamelCase(state.name))
pdict['len'] = state.len
stmt = apply_pdict(tmpl, pdict)
expr = "isValid(data_ff.first)"
ifstmt = []
ifstmt.append(ast.Template("report_parse_action(parse_state_ff.first, rg_buffered[0], data_this_cycle, rg_tmp[0]);"))
ifstmt.append(ast.If(expr, stmt))
rcond = '(parse_state_ff.first == %(CurrState)s) && (rg_buffered[0] < %(len)s)' % pdict
attr = ['fire_when_enabled']
rule = ast.Rule('rl_%(name)s_load' % pdict, rcond, ifstmt, attr)
return [rule]
def buildRuleExecuteAction(self):
TMP1 = "let rsp <- matchTable.lookupPort.response.get;"
TMP2 = "let pkt <- toGet(packet_ff).get;"
TMP3 = "let meta <- toGet(metadata_ff[0]).get;"
TMP4 = "%(type)s resp = unpack(data);"
TMP7 = "metadata_ff[1].enq(meta);"
TMP8 = "BBRequest req = tagged %(type)sReqT {%(field)s};"
TMP9 = "bbReqFifo[%(id)s].enq(req); //FIXME: replace with RXTX."
stmt = []
stmt.append(ast.Template(TMP1))
stmt.append(ast.Template(TMP2))
stmt.append(ast.Template(TMP3))
case_stmt = ast.Case("resp._action")
for idx, action in enumerate(self.actions):
basic_block = self.basic_block_map[action]
fields = basic_block.request.build_case_expr()
action_stmt = []
action_stmt.append(
ast.Template(TMP8, {
"type": CamelCase(action),
"field": fields
}))
action_stmt.append(ast.Template(TMP9, {"id": idx}))
_action = action.lstrip('_').upper()
case_stmt.casePatStmt[_action] = action_stmt
if_stmt = ast.If("rsp matches tagged Valid .data", [])
if_stmt.stmt.append(ast.Template(TMP4, {"type": self.rsp_name}))
if_stmt.stmt.append(case_stmt)
if_stmt.stmt.append(ast.Template("// forward metadata to next stage."))
if_stmt.stmt.append(ast.Template(TMP7))
stmt.append(if_stmt)
rname = "rl_handle_execute"
cond = []
rule = ast.Rule(rname, cond, stmt)
return rule
def build_funct(name, parameters, transition):
ab_stmt = []
if len(parameters) == 0 or (len(parameters) == 1 and transition[0]['value'] == 'start'):
for t in transition:
_, _, _stmt = build_transition(name, t)
ab_stmt += _stmt
else:
key_stmt = ast.Template("let v = {%s};" % (", ".join([p[1] for p in parameters])))
ab_stmt.append(key_stmt)
for idx, t in enumerate(transition):
_value, _mask, _stmt = build_transition(name, t)
expr = "(v & %s) == %s" % (_mask, _value) if _mask != None else "v == %s" % (_value)
if _value == 'start' or _value == 'default':
ab_stmt.append(ast.Else(_stmt))
else:
if idx == 0:
ab_stmt.append(ast.If(expr, _stmt))
else:
ab_stmt.append(ast.ElseIf(expr, _stmt))
stmt = apply_action_block(ab_stmt)
params = ', '.join(["Bit#(%s) %s" % (p[0], p[1]) for p in parameters])
f = ast.Function("compute_next_state_%s"%(name), 'Action', params, stmt)
return f
def apply_if_verbosity(verbosity, stmt):
assert type(stmt) is list
assert type(verbosity) is int
return [ast.If("cr_verbosity[0] > %d" % (verbosity), stmt)]