def test(cls,
config_name,
is_export=True,
is_update_map=True,
is_simulate=False):
assert config_name == 'config_line'
cfgHelper = ConfigDataHelper(config_name, is_export)
cfgHelper.init_task_graph()
cfgHelper.update_topo_device_graph()
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
all_mobiles = ['CAMERA.0', 'CAMERA.1', 'PHONE.0']
all_aps = ['BB_AP.0', 'BB_AP.1', 'BB_AP.2', 'BB_AP.3', 'BB_AP.4']
all_sws = [
'BB_SWITCH.0', 'BB_SWITCH.1', 'BB_SWITCH.2', 'BB_SWITCH.3',
'BB_SWITCH.4'
]
update_id = -1
for i in range(1, 50):
update_id += 1
log.info('=== update {}: change link dst ==='.format(update_id))
dev = random.sample(all_mobiles, 1)[0]
edges = list(topo_device_graph.edges(dev))
assert len(edges) == 1
nw_dev = edges[0][1]
assert nw_dev in all_aps, '{} not in {}'.format(nw_dev, all_aps)
new_nw_dev = random.sample(all_aps, 1)[0]
new_latency = Unit.ms(random.randint(1, 500))
cfgHelper.update_dev_link(dev, nw_dev, new_nw_dev, new_latency)
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
# update device graph
update_id += 1
log.info('=== update {}: change latency ==='.format(update_id))
edges = list(topo_device_graph.edges())
[nw_dev1, nw_dev2] = random.sample(all_aps + all_sws, 2)
while (nw_dev1, nw_dev2) not in edges:
[nw_dev1, nw_dev2] = random.sample(all_aps + all_sws, 2)
latency = Unit.ms(random.randint(20, 5000))
cfgHelper.update_nw_link_latency(nw_dev1, nw_dev2, latency)
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
latency_dynamic, latency_static = cfgHelper.get_max_latency_log()
log.info('latency_dynamic: {}'.format(latency_dynamic))
log.info('latency_static: {}'.format(latency_static))
def test(cls,
config_name=None,
is_export=True,
is_update_map=False,
is_simulate=False):
cfgHelper = ConfigDataHelper(config_name, is_export)
cfgHelper.init_task_graph()
cfgHelper.update_topo_device_graph()
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
_topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
update_id = 0
log.info('=== update round {} ==='.format(update_id))
dev = 'PHONE.0'
nw_dev = 'BB_AP.0'
new_nw_dev = 'HOME_IOTGW.0'
new_latency = Unit.ms(3)
cfgHelper.update_dev_link(dev, nw_dev, new_nw_dev, new_latency)
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
_topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
# update device graph
update_id += 1
log.info('=== update round {} ==='.format(update_id))
nw_dev1 = 'BB_SWITCH.0'
nw_dev2 = 'CLOUD_SWITCH.0'
latency = Unit.sec(5)
cfgHelper.update_nw_link_latency(nw_dev1, nw_dev2, latency)
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
_topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
# update device graph
update_id += 1
log.info('=== update round {} ==='.format(update_id))
dev = 'PHONE.0'
nw_dev = 'HOME_IOTGW.0'
new_nw_dev = 'BB_AP.0'
new_latency = Unit.ms(3)
cfgHelper.update_dev_link(dev, nw_dev, new_nw_dev, new_latency)
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
_topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
log.info('latency trend: {}'.format(cfgHelper.get_max_latency_log()))
def test(cls,
config_name=None,
is_export=False,
is_update_map=True,
is_simulate=False):
if not config_name:
config_name = 'sample_configs/config_ddflow_phase1'
assert config_name == 'sample_configs/config_ddflow_phase1'
cfg = Config(config_name)
cfgHelper = ConfigDataHelper(cfg, is_export)
cfgHelper.init_task_graph()
cfgHelper.update_topo_device_graph()
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
# all_devices = [
# 'P3_2XLARGE.0',
# 'T3_LARGE.0',
# 'T2_MICRO.0']
# all_sws = [
# 'CENTER_SWITCH.0',
# 'FIELD_SWITCH.0',
# 'FIELD_SWITCH.1',
# 'BB_SWITCH.0',
# 'BB_SWITCH.1',
# 'BB_SWITCH.2']
update_id = -1
for i in range(1, 100):
update_id += 1
log.info('=== update {}: dev-nw_dev link ==='.format(update_id))
dev = 'P3_2XLARGE.0'
nw_dev = 'CENTER_SWITCH.0'
latency = Unit.ms(random.randint(2, 2000))
cfgHelper.update_dev_link_latency(dev, nw_dev, latency)
dev = 'CONTROLLER.0'
nw_dev = 'CENTER_SWITCH.0'
latency = Unit.ms(random.randint(2, 200))
cfgHelper.update_dev_link_latency(dev, nw_dev, latency)
dev = 'T3_LARGE.0'
nw_dev = 'FIELD_SWITCH.1'
latency = Unit.ms(random.randint(2, 200))
cfgHelper.update_dev_link_latency(dev, nw_dev, latency)
# update graph and map
cfgHelper.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
if is_simulate:
cls._simulate(topo_device_graph, Gd, G_map)
latency_dynamic, latency_static = cfgHelper.get_max_latency_log()
print('static\tdynamic\tdiff')
for t1, t2 in zip(latency_static, latency_dynamic):
print('{}\t{}\t{}'.format(t1, t2, t2 - t1))
def _derive_node_info(device_spec, device_inventory):
all_device_info = {}
inventory_manager = InventoryManager(device_inventory)
device_record = inventory_manager.get_device_record()
for device_cat, inventory_info in iteritems(device_record):
for device_type, device_list in iteritems(inventory_info):
for device_name in device_list:
# copy hardware spec
spec = device_spec[device_cat][device_type]
device_info = {
GInfo.NODE_TYPE:
NodeType.DEVICE,
GdInfo.DEVICE_CAT:
device_cat,
GdInfo.DEVICE_TYPE:
device_type,
GdInfo.COST:
spec[GdInfo.COST],
GdInfo.HARDWARE:
spec[GdInfo.HARDWARE],
GdInfo.NIC:
deepcopy(spec[GdInfo.NIC]),
# TODO: bandwidth is a resource
GdInfo.RESRC:
deepcopy(spec[GdInfo.HARDWARE]),
}
# special setting for RESRC info of GPU/CPU
for hw_type in [Hardware.CPU, Hardware.GPU]:
if hw_type in device_info[GdInfo.RESRC]:
device_info[GdInfo.RESRC][hw_type] = (
Unit.percentage(100))
all_device_info[device_name] = device_info
return all_device_info
def test(cls,
config_name=None,
is_export=True,
is_update_map=True,
is_simulate=True):
if not config_name:
config_name = 'sample_configs/config_ddflow_demo'
_check_support_config(config_name)
cfgHelper = ConfigDataHelper(Config(config_name), is_export)
cfgHelper.init_task_graph()
cfgHelper.update_topo_device_graph()
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
# scenarios:
# (1) initial deployment, all links are alive
# (2) P3.X2LARGE.0 poor connection
# (3) T3.XLARGE.0 poor connection
# (4) P3.X2LARGE.0 back online
if is_simulate:
log.info("=== start mininet ===")
_topo, topo_device_graph, Gd, G_map = cfgHelper.get_graphs()
_control_plane, data_plane = _init_netsim(topo_device_graph, Gd,
G_map)
raw_input('press any key to start the network')
data_plane.start(is_validate=True)
data_plane.print_net_info()
raw_input('press any key to start scenario 1')
log.info('=== running scenario 1: initial deployment ===')
data_plane.start_workers()
data_plane.print_net_info()
raw_input('press any key to start scenario 2')
log.info('=== running scenario 2: P3_2XLARGE.0 poor connection ===')
nw_dev1 = 'BB_SWITCH.0'
nw_dev2 = 'CENTER_SWITCH.1'
new_latency = Unit.ms(1000)
cls.update_nw_latency(cfgHelper, data_plane, nw_dev1, nw_dev2,
new_latency, is_simulate)
if is_update_map:
cls.update_placement(cfgHelper, data_plane, is_simulate)
data_plane.print_net_info()
raw_input('press any key to start scenario 3')
log.info('=== running scenario 3: T3_LARGE.0 poor connection ===')
nw_dev1 = 'BB_SWITCH.1'
nw_dev2 = 'FIELD_SWITCH.1'
new_latency = Unit.ms(2000)
cls.update_nw_latency(cfgHelper, data_plane, nw_dev1, nw_dev2,
new_latency, is_simulate)
if is_update_map:
cls.update_placement(cfgHelper, data_plane, is_simulate)
data_plane.print_net_info()
raw_input('press any key to start scenario 4')
log.info('=== running scenario 4: P3_2XLARGE.0 back online ===')
nw_dev1 = 'BB_SWITCH.0'
nw_dev2 = 'CENTER_SWITCH.1'
new_latency = Unit.ms(2)
cls.update_nw_latency(cfgHelper, data_plane, nw_dev1, nw_dev2,
new_latency, is_simulate)
if is_update_map:
cls.update_placement(cfgHelper, data_plane, is_simulate)
raw_input('press any key to end test')
if is_simulate:
data_plane.stop_workers()
data_plane.stop()
log.info('latency trend: {}'.format(cfgHelper.get_max_latency_log()))
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from placethings.definition import (Const, Device, DeviceCategory, GdInfo,
Hardware, LinkInfo, LinkType, NwDevice,
NwDeviceCategory, NwLink, Unit)
NW_DEVICE_SPEC = {
NwDeviceCategory.HOME: {
NwDevice.HOME_ROUTER: {
LinkType.WAN: {
LinkInfo.PROTOCOL: NwLink.ETHERNET,
LinkInfo.N_LINKS: 1,
LinkInfo.ULINK_BW: Unit.mbps(500),
LinkInfo.DLINK_BW: Unit.mbps(500),
},
LinkType.LAN: {
LinkInfo.PROTOCOL: NwLink.ETHERNET,
LinkInfo.N_LINKS: 5,
LinkInfo.ULINK_BW: Unit.mbps(100),
LinkInfo.DLINK_BW: Unit.mbps(100),
},
},
NwDevice.HOME_IOTGW: {
LinkType.WAN: {
LinkInfo.PROTOCOL: NwLink.ETHERNET,
LinkInfo.N_LINKS: 1,
LinkInfo.ULINK_BW: Unit.mbps(500),
LinkInfo.DLINK_BW: Unit.mbps(500),
NwDeviceCategory.BACKBONE: {
NwDevice.BB_SWITCH: 1,
NwDevice.BB_AP: 1,
},
NwDeviceCategory.CLOUD: {
NwDevice.CLOUD_SWITCH: 1,
},
}
# device naming rule: DeviceTypeName.ID
NW_LINKS = {
'HOME_IOTGW.0 -> HOME_ROUTER.0': {
GnInfo.SRC_LINK_TYPE: LinkType.WAN,
GnInfo.DST_LINK_TYPE: LinkType.LAN,
GnInfo.LATENCY: Unit.ms(1),
},
'HOME_ROUTER.0 -> HOME_IOTGW.0': {
GnInfo.SRC_LINK_TYPE: LinkType.LAN,
GnInfo.DST_LINK_TYPE: LinkType.WAN,
GnInfo.LATENCY: Unit.ms(1),
},
'HOME_ROUTER.0 -> BB_SWITCH.0': {
GnInfo.SRC_LINK_TYPE: LinkType.WAN,
GnInfo.DST_LINK_TYPE: LinkType.ANY,
GnInfo.LATENCY: Unit.ms(20),
},
'BB_SWITCH.0 -> HOME_ROUTER.0': {
GnInfo.SRC_LINK_TYPE: LinkType.ANY,
GnInfo.DST_LINK_TYPE: LinkType.WAN,
GnInfo.LATENCY: Unit.ms(20),
def test(cls,
config_name,
is_export=False,
is_update_map=False,
is_simulate=False):
assert config_name == 'config_ddflow_phase2'
# TODO: clean this shit
cfg1 = Config('{}.1'.format(config_name))
cfg2 = Config('{}.2'.format(config_name))
cfgHelper = ConfigDataHelper(cfg1, is_export)
cfgHelper.init_task_graph()
cfgHelper.update_topo_device_graph()
cfgHelper.update_task_map()
cfgHelper.update_max_latency_log()
cfgHelper2 = ConfigDataHelper(cfg2, is_export)
cfgHelper2.init_task_graph()
cfgHelper2.update_topo_device_graph()
cfgHelper2.update_task_map()
cfgHelper2.update_max_latency_log()
all_mobiles = ['CAMERA.0']
all_aps = ['BB_AP.0', 'BB_AP.1', 'BB_AP.2']
update_id = -1
for i in range(1, 100):
update_id += 1
log.info('=== update {}: mobile-ap link ==='.format(update_id))
dev = random.sample(all_mobiles, 1)[0]
_, topo_device_graph, _, _ = cfgHelper.get_graphs()
edges = list(topo_device_graph.edges(dev))
assert len(edges) == 1
nw_dev = edges[0][1]
assert nw_dev in all_aps, '{} not in {}'.format(nw_dev, all_aps)
new_nw_dev = random.sample(all_aps, 1)[0]
new_latency = Unit.ms(random.randint(30, 50))
cfgHelper.update_dev_link(dev, nw_dev, new_nw_dev, new_latency)
cfgHelper2.update_dev_link(dev, nw_dev, new_nw_dev, new_latency)
log.info('=== update {}: ap-bb link ==='.format(update_id))
ap_bb_links = [
# ('BB_AP.0', 'BB_SWITCH.0'),
('BB_AP.1', 'BB_SWITCH.1'),
('BB_AP.2', 'BB_SWITCH.2')
]
[which_link] = random.sample(ap_bb_links, 1)
which_rand = random.randint(0, 9)
if which_rand < 5:
latency = Unit.ms(random.randint(5000, 6000))
else:
latency = Unit.ms(random.randint(30, 50))
nw_dev1, nw_dev2 = which_link
cfgHelper.update_nw_link_latency(nw_dev1, nw_dev2, latency)
cfgHelper2.update_nw_link_latency(nw_dev1, nw_dev2, latency)
log.info('=== update {}: ap-ap link ==='.format(update_id))
# _, topo_device_graph, _, _ = cfgHelper2.get_graphs()
# edges = list(topo_device_graph.edges())
ap_ap_links = [('BB_AP.0', 'BB_AP.1'), ('BB_AP.1', 'BB_AP.2')]
[which_link] = random.sample(ap_ap_links, 1)
latency = Unit.ms(random.randint(30, 50))
nw_dev1, nw_dev2 = which_link
cfgHelper2.update_nw_link_latency(nw_dev1, nw_dev2, latency)
log.info('=== update {}: update graphs ==='.format(update_id))
cfgHelper.update_topo_device_graph()
cfgHelper2.update_topo_device_graph()
if is_update_map:
cfgHelper.update_task_map()
cfgHelper2.update_task_map()
cfgHelper.update_max_latency_log()
cfgHelper2.update_max_latency_log()
_, latency_static = cfgHelper.get_max_latency_log()
_, latency_static2 = cfgHelper2.get_max_latency_log()
print('static\tdynamic\tdiff')
for t1, t2 in zip(latency_static, latency_static2):
print('{}\t{}\t{}'.format(t1, t2, t2 - t1))
def test(config_name=None, is_export=False):
if not config_name:
config_name = _DEFAULT_CONFIG
# generate device graph
dev_file = FileHelper.gen_config_filepath(config_name, 'device_data')
nw_file = FileHelper.gen_config_filepath(config_name, 'nw_device_data')
spec, inventory, links = device_data.import_data(dev_file)
nw_spec, nw_inventory, nw_links = nw_device_data.import_data(nw_file)
Gd = device_graph.create_graph(spec, inventory, links, nw_spec,
nw_inventory, nw_links, is_export)
# generate task graph
Gt = graph_factory.gen_task_graph(config_name, is_export)
Gt = ilp_solver.place_things(Gt, Gd, is_export)
update_id = 0
# update device graph
update_id += 1
log.info('update round {}'.format(update_id))
suffix = '_update{}'.format(update_id)
del links['PHONE.0 -> BB_AP.0']
del links['BB_AP.0 -> PHONE.0']
links['PHONE.0 -> HOME_IOTGW.0'] = {
GnInfo.LATENCY: Unit.ms(3),
}
links['HOME_IOTGW.0 -> PHONE.0'] = {
GnInfo.LATENCY: Unit.ms(3),
}
Gd = device_graph.create_graph(
spec,
inventory,
links,
nw_spec,
nw_inventory,
nw_links,
is_export,
export_suffix='_update{}'.format(update_id))
Gt = ilp_solver.place_things(Gt, Gd, is_export, export_suffix=suffix)
# update device graph
update_id += 1
log.info('update round {}'.format(update_id))
suffix = '_update{}'.format(update_id)
nw_links['BB_SWITCH.0 -> CLOUD_SWITCH.0'][GnInfo.LATENCY] = Unit.sec(5)
nw_links['CLOUD_SWITCH.0 -> BB_SWITCH.0'][GnInfo.LATENCY] = Unit.sec(5)
Gd = device_graph.create_graph(spec,
inventory,
links,
nw_spec,
nw_inventory,
nw_links,
is_export,
export_suffix=suffix)
Gt = ilp_solver.place_things(Gt, Gd, is_export, export_suffix=suffix)
# update device graph
update_id += 1
log.info('update round {}'.format(update_id))
suffix = '_update{}'.format(update_id)
del links['PHONE.0 -> HOME_IOTGW.0']
del links['HOME_IOTGW.0 -> PHONE.0']
links['PHONE.0 -> BB_AP.0'] = {
GnInfo.LATENCY: Unit.ms(3),
}
links['BB_AP.0 -> PHONE.0'] = {
GnInfo.LATENCY: Unit.ms(3),
}
Gd = device_graph.create_graph(
spec,
inventory,
links,
nw_spec,
nw_inventory,
nw_links,
is_export,
export_suffix='_update{}'.format(update_id))
Gt = ilp_solver.place_things(Gt, Gd, is_export, export_suffix=suffix)
# update device graph
update_id += 1
log.info('update round {}'.format(update_id))
suffix = '_update{}'.format(update_id)
nw_links['BB_SWITCH.0 -> CLOUD_SWITCH.0'][GnInfo.LATENCY] = Unit.ms(5)
nw_links['CLOUD_SWITCH.0 -> BB_SWITCH.0'][GnInfo.LATENCY] = Unit.ms(5)
Gd = device_graph.create_graph(spec,
inventory,
links,
nw_spec,
nw_inventory,
nw_links,
is_export,
export_suffix=suffix)
Gt = ilp_solver.place_things(Gt, Gd, is_export, export_suffix=suffix)
class TopoGraph(object):
_DEFAULT_DENSITY = 0.3
_DEFAULT_LATENCY = Unit.ms(20)
_DEFAULT_BANDWIDTH = Unit.mbyte(300)
# default nodes in the topology if not present in input arguments
_DEFAULT_N_SWITCH = 10
_DEFAULT_N_DEVICE = 5
_DEFAULT_N_SOURCE = 3
_DEFAULT_N_DESTINATION = 1
_DEFAULT_PREFIX_SWITCH = 'sw'
_DEFAULT_PREFIX_DEVICE = 'dv'
_DEFAULT_PREFIX_SOURCE = 'src'
_DEFAULT_PREFIX_DESTINATION = 'dst'
@classmethod
def create_default_switch_list(cls, n_switch=None):
# expose this function to network graph
if not n_switch:
n_switch = cls._DEFAULT_N_SWITCH
return cls._create_node_list(n_switch, cls._DEFAULT_PREFIX_SWITCH)
@classmethod
def _create_node_list(cls, n_node, node_prefix):
return ['{}.{}'.format(node_prefix, i) for i in range(n_node)]
@classmethod
def _add_random_link(cls, graph, src, dst, bandwidth=None, latency=None):
if not bandwidth:
bandwidth = cls._DEFAULT_BANDWIDTH
if not latency:
latency = cls._DEFAULT_LATENCY
attr = {
GnInfo.BANDWIDTH: int(round(bandwidth * random.random())),
GnInfo.LATENCY: int(round(latency * random.random())),
}
graph.add_edge(src, dst, **attr)
@classmethod
def create_default_topo(cls, switch_list, device_list=None):
"""
Randomly deploy devices in a newtork consists of randomly connected
switches.
Args:
switch_list (list): a list of APs, routers, switchs, etc
device_list (list): a list of devices
Returns:
topology (networkx.DiGraph)
"""
if not device_list:
device_list = []
graph = nx.DiGraph()
graph.add_nodes_from(switch_list)
n_edge_per_switch = int(round(cls._DEFAULT_DENSITY * len(switch_list)))
for s1 in switch_list:
for s2 in random.sample(switch_list, n_edge_per_switch):
if s1 == s2:
continue
cls._add_random_link(graph, s1, s2)
cls._add_random_link(graph, s2, s1)
graph.add_nodes_from(device_list)
for node in device_list:
# connect device to a random selected switch
[switch] = random.sample(switch_list, 1)
# randomly assign bandwidth and latency
cls._add_random_link(graph, node, switch)
cls._add_random_link(graph, switch, node)
return graph
def test(config_name=None, is_export=False):
if not config_name:
config_name = 'sample_configs/config_sample'
cfg = Config()
cfg.add_nw_device(NwDeviceCategory.FIELD, NwDevice.FIELD_SWITCH, 2)
cfg.add_nw_device(NwDeviceCategory.BACKBONE, NwDevice.BB_SWITCH, 3)
cfg.add_nw_device(NwDeviceCategory.BACKBONE, NwDevice.BB_AP, 3)
cfg.add_nw_device(NwDeviceCategory.CLOUD, NwDevice.CLOUD_SWITCH, 2)
cfg.add_nw_dev_link('CLOUD_SWITCH.1', 'BB_SWITCH.0', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('CLOUD_SWITCH.0', 'BB_SWITCH.0', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('FIELD_SWITCH.1', 'BB_SWITCH.1', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('FIELD_SWITCH.0', 'BB_SWITCH.2', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('BB_AP.0', 'BB_SWITCH.0', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('BB_AP.1', 'BB_SWITCH.1', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('BB_AP.2', 'BB_SWITCH.2', LinkType.WAN,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('BB_SWITCH.0', 'BB_SWITCH.1', LinkType.ANY,
LinkType.ANY, Unit.ms(2))
cfg.add_nw_dev_link('BB_SWITCH.1', 'BB_SWITCH.2', LinkType.ANY,
LinkType.ANY, Unit.ms(2))
cfg.add_device(DeviceCategory.SENSOR, Device.CAMERA, 1)
cfg.add_device(DeviceCategory.PROCESSOR, Device.P3_2XLARGE, 1)
cfg.add_device(DeviceCategory.PROCESSOR, Device.T3_LARGE, 1)
cfg.add_device(DeviceCategory.PROCESSOR, Device.T2_MICRO, 1)
cfg.add_device(DeviceCategory.ACTUATOR, Device.CONTROLLER, 1)
cfg.add_dev_link('CAMERA.0', 'BB_AP.0', Unit.ms(30))
cfg.add_dev_link('P3_2XLARGE.0', 'CLOUD_SWITCH.0', Unit.ms(2))
cfg.add_dev_link('T3_LARGE.0', 'FIELD_SWITCH.1', Unit.ms(2))
cfg.add_dev_link('T2_MICRO.0', 'FIELD_SWITCH.0', Unit.ms(2))
cfg.add_dev_link('CONTROLLER.0', 'CLOUD_SWITCH.1', Unit.ms(2))
cfg.add_task('task_takePic')
cfg.add_task('task_findObj')
cfg.add_task('task_notify')
cfg.add_task_link('task_takePic', 'task_findObj', Unit.mbyte(12))
cfg.add_task_link('task_findObj', 'task_notify', Unit.byte(10))
flavor = TaskFlavor(Flavor.CPU)
flavor.add_requirement(Hardware.RAM, Unit.gbyte(1))
flavor.add_requirement(Hardware.HD, Unit.mbyte(30))
flavor.add_requirement(Hardware.GPU, Unit.percentage(0))
flavor.add_requirement(Hardware.CPU, Unit.percentage(60))
flavor.add_latency_info(Device.T2_MICRO, Unit.sec(6))
flavor.add_latency_info(Device.T3_LARGE, Unit.sec(2))
flavor.add_latency_info(Device.P3_2XLARGE, Unit.ms(600))
cfg.add_task_flavor('task_findObj', flavor)
flavor = TaskFlavor(Flavor.GPU)
flavor.add_requirement(Hardware.RAM, Unit.gbyte(4))
flavor.add_requirement(Hardware.HD, Unit.mbyte(30))
flavor.add_requirement(Hardware.GPU, Unit.percentage(60))
flavor.add_requirement(Hardware.CPU, Unit.percentage(5))
flavor.add_latency_info(Device.P3_2XLARGE, Unit.ms(20))
cfg.add_task_flavor('task_findObj', flavor)
cfg.add_task_mapping('task_takePic', 'CAMERA.0')
cfg.add_task_mapping('task_notify', 'CONTROLLER.0')
cfg.export_data(config_name)
cfg2 = Config(folderpath=config_name)
compare_cfg(cfg, cfg2)