hw_spec = importlib.import_module(HW, "*")
latency_spec = importlib.import_module(LATENCY, "*")
for i in range(0, 4):
branch_spec[i].action_fields_limit = hw_spec.action_fields_limit
branch_spec[i].match_unit_limit = hw_spec.match_unit_limit
branch_spec[i].match_unit_size = hw_spec.match_unit_size
branch_spec[i].action_proc_limit = hw_spec.action_proc_limit
branch_spec[i].match_proc_limit = hw_spec.match_proc_limit
# Create graphs for all branches
graphs_map = {}
for i in range(0, 4):
graphs_map[i] = ScheduleDAG()
graphs_map[i].create_dag(branch_spec[i].nodes, branch_spec[i].edges,
latency_spec)
common_nodes_mapping = {}
for i in range(0, 3):
common_nodes_mapping[i] = {}
for j in range(i + 1, 4):
common_nodes_mapping[i][j] = get_common_nodes(
graphs_map[i], graphs_map[j])
match_key_size = {}
for i in range(0, 4):
print("Branch " + str(i) + " nodes length", len(graphs_map[i].nodes()))
print("Branch " + str(i) + " match nodes length",
len(graphs_map[i].nodes(select='match')))
hw_file = sys.argv[2]
latency_file = sys.argv[3]
minute_limit = int(sys.argv[4])
# Input specification
input_spec = importlib.import_module(input_file, "*")
hw_spec = importlib.import_module(hw_file, "*")
latency_spec=importlib.import_module(latency_file, "*")
input_spec.action_fields_limit = hw_spec.action_fields_limit
input_spec.match_unit_limit = hw_spec.match_unit_limit
input_spec.match_unit_size = hw_spec.match_unit_size
input_spec.action_proc_limit = hw_spec.action_proc_limit
input_spec.match_proc_limit = hw_spec.match_proc_limit
# Create G
G = ScheduleDAG()
G.create_dag(input_spec.nodes, input_spec.edges, latency_spec)
cpath, cplat = G.critical_path()
print ('{:*^80}'.format(' Input DAG '))
tpt_upper_bound = print_problem(G, input_spec)
tpt_lower_bound = 0.01 # Just for kicks
print ('\n\n')
# Try to max. throughput
# We do this by min. the period
period_lower_bound = int(math.ceil((1.0) / tpt_upper_bound))
period_upper_bound = int(math.ceil((1.0) / tpt_lower_bound))
period = period_upper_bound
last_good_solution = None
last_good_period = None
hw_file = sys.argv[2]
latency_file = sys.argv[3]
assert ((sys.argv[4] == "coarse") or (sys.argv[4] == "fine"))
solve_coarse = bool(sys.argv[4] == "coarse")
# Input example
input_spec = importlib.import_module(input_file, "*")
hw_spec = importlib.import_module(hw_file, "*")
latency_spec = importlib.import_module(latency_file, "*")
input_spec.action_fields_limit = hw_spec.action_fields_limit
input_spec.match_unit_limit = hw_spec.match_unit_limit
input_spec.match_unit_size = hw_spec.match_unit_size
input_spec.action_proc_limit = hw_spec.action_proc_limit
input_spec.match_proc_limit = hw_spec.match_proc_limit
G = ScheduleDAG()
G.create_dag(input_spec.nodes, input_spec.edges, latency_spec)
print('{:*^80}'.format(' Input DAG '))
print_problem(G, input_spec)
print('{:*^80}'.format(' Scheduling PRMT fine '))
solver = PrmtFineSolver(G, input_spec, latency_spec, seed_greedy=True)
solution = solver.solve(solve_coarse)
print('Number of pipeline stages: %f' % (math.ceil(solution.length / 2.0)))
print('{:*^80}'.format(' Schedule'))
print(
timeline_str(solution.ops_at_time, white_space=0, timeslots_per_row=4),
'\n\n')
print_resource_usage(input_spec, solution)
exit(1)
else :
input_spec = importlib.import_module(sys.argv[1], "*")
hw_spec = importlib.import_module(sys.argv[2], "*")
latency_spec = importlib.import_module(sys.argv[3], "*")
minute_limit = int(sys.argv[4])
seed = int(sys.argv[5])
burst_size = int(sys.argv[6])
input_spec.action_fields_limit = hw_spec.action_fields_limit
input_spec.match_unit_limit = hw_spec.match_unit_limit
input_spec.match_unit_size = hw_spec.match_unit_size
input_spec.action_proc_limit = hw_spec.action_proc_limit
input_spec.match_proc_limit = hw_spec.match_proc_limit
graph_map = ScheduleDAG()
t_nodes, t_edges = create_compund_graph(input_spec.nodes, input_spec.edges, burst_size)
graph_map.create_dag(t_nodes, t_edges, latency_spec)
print(graph_map.critical_path())
print(len(graph_map.nodes()))
last_good_soln = None
last_good_period = None
for period in range(seed+5, seed-5, -1):
soln = model_ilp(graph_map, hw_spec, period, minute_limit, burst_size)
if (soln):
last_good_period = period
branch1_spec.action_fields_limit = hw_spec.action_fields_limit
branch1_spec.match_unit_limit = hw_spec.match_unit_limit
branch1_spec.match_unit_size = hw_spec.match_unit_size
branch1_spec.action_proc_limit = hw_spec.action_proc_limit
branch1_spec.match_proc_limit = hw_spec.match_proc_limit
branch2_spec.action_fields_limit = hw_spec.action_fields_limit
branch2_spec.match_unit_limit = hw_spec.match_unit_limit
branch2_spec.match_unit_size = hw_spec.match_unit_size
branch2_spec.action_proc_limit = hw_spec.action_proc_limit
branch2_spec.match_proc_limit = hw_spec.match_proc_limit
# Create graphs for both branches
G1 = ScheduleDAG()
G2 = ScheduleDAG()
G1.create_dag(branch1_spec.nodes, branch1_spec.edges, latency_spec)
G2.create_dag(branch2_spec.nodes, branch2_spec.edges, latency_spec)
# Group common nodes
common_nodes_mapping = get_common_nodes(G1, G2)
#print (common_nodes_mapping)
print ("Branch1 - nodes", len(G1.nodes()) )
print ("Branch1 - match nodes", len(G1.nodes(select='match')))
match_nodes = G1.nodes(select='match')
action_nodes = G1.nodes(select='action')
match_key_size = 0
action_key_size = 0
def contract_dag(input_spec, latency_spec):
G = ScheduleDAG()
G.create_dag(input_spec.nodes, input_spec.edges, latency_spec)
action_nodes = G.nodes(select='action')
match_nodes = G.nodes(select='match')
tables = []
found_table = dict()
for m in match_nodes:
for a in action_nodes:
if (a.startswith("_condition")):
continue
assert (m.endswith('MATCH'))
assert (a.endswith('ACTION'))
m_table = m.strip('MATCH')
a_table = a.strip('ACTION')
if (m_table == a_table):
tables.append((m, a))
found_table[m] = True
found_table[a] = True
for m in match_nodes:
if m not in found_table:
print("Unpaired match, ERROR!!!")
exit(1)
for a in action_nodes:
if a not in found_table:
pass
# print ("Unpaired action or condition: ", a, file=sys.stderr)
# Contract table edges
for table in tables:
match = table[0]
action = table[1]
table_name = match.strip('MATCH') + 'TABLE'
key_width = G.node[match]['key_width']
num_fields = G.node[action]['num_fields']
G = nx.contracted_edge(G, table, self_loops=False)
nx.relabel_nodes(G, {match: table_name}, False)
G.node[table_name]['type'] = 'table'
G.node[table_name]['key_width'] = key_width
G.node[table_name]['num_fields'] = num_fields
# Create dummy tables for the rest
for v in G.nodes():
if (G.node[v]['type'] != 'table'):
G.node[v]['type'] = 'table'
G.node[v]['key_width'] = 0
assert (G.node[v]['num_fields'] >= 0)
# leave num_fields unchanged
return G
hw_file = sys.argv[2]
latency_file = sys.argv[3]
minute_limit = int(sys.argv[4])
burst_size = int(sys.argv[5])
# Input specification
input_spec = importlib.import_module(input_file, "*")
hw_spec = importlib.import_module(hw_file, "*")
latency_spec=importlib.import_module(latency_file, "*")
input_spec.action_fields_limit = hw_spec.action_fields_limit
input_spec.match_unit_limit = hw_spec.match_unit_limit
input_spec.match_unit_size = hw_spec.match_unit_size
input_spec.action_proc_limit = hw_spec.action_proc_limit
input_spec.match_proc_limit = hw_spec.match_proc_limit
G = ScheduleDAG()
G.create_dag(input_spec.nodes, input_spec.edges, latency_spec)
cpath, cplat = G.critical_path()
match_nodes = G.nodes(select='match')
action_nodes = G.nodes(select='action')
match_key_size = 0
action_key_size = 0
for node in match_nodes:
match_key_size += G.node[node]['key_width']
for node in action_nodes:
action_key_size += G.node[node]['num_fields']