def setUp(self):
self.layers = {}
self.layers['BASE'] = ConvLayer(8, 16, 28, 3)
self.layers['POOL'] = PoolingLayer(16, 28, 2)
self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1)
self.batch_size = 4
self.cost = Cost(mac_op=1, mem_hier=(200, 6, 2, 1),
noc_hop=50, unit_static=50)
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 4),
type=NodeRegion.PROC),
data_regions=(NodeRegion(origin=PhyDim2(0, 0), dim=PhyDim2(4, 1),
type=NodeRegion.DATA),),
dim_array=PhyDim2(16, 16), size_gbuf=65536, size_regf=64)
self.options = Option(partition_hybrid=True, partition_batch=True,
partition_ifmaps=True, ntops=10)
self.ifmap_layouts = {}
part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP),
pdims=((1, 2), (2, 1), (1, 2), (2, 1)))
for wlkey in self.layers:
self.ifmap_layouts[wlkey] = partition.get_ofmap_layout(
self.layers[wlkey].input_layer(), self.batch_size, part,
self.resource.src_data_region())
def test_gen_segment_not_opt(self):
''' gen_segment() not with_opt. '''
options_with_opt = Option(partition_interlayer=True,
hw_gbuf_save_writeback=True,
layer_pipeline_opt=True)
options_not_opt = Option(partition_interlayer=True,
hw_gbuf_save_writeback=True,
layer_pipeline_opt=False)
# Linear ones
for net_name in ['net1', 'net2', 'zfnet']:
net = self.net[net_name]
ilp = self._make_ilp(net)
segs_with_opt = set(seg.seg
for seg in ilp.gen_segment(options_with_opt))
segs_not_opt = set(seg.seg
for seg in ilp.gen_segment(options_not_opt))
self.assertSetEqual(segs_with_opt, segs_not_opt)
# Non-linear ones
for net_name in ['net3', 'net4', 'net5', 'net6', 'net7', 'googlenet']:
net = self.net[net_name]
ilp = self._make_ilp(net)
segs_with_opt = set(seg.seg
for seg in ilp.gen_segment(options_with_opt))
segs_not_opt = set(seg.seg
for seg in ilp.gen_segment(options_not_opt))
self.assertTrue(segs_with_opt.issuperset(segs_not_opt))
def setUp(self):
self.layers = {}
self.layers['BASE'] = ConvLayer(8, 16, 28, 3)
self.layers['POOL'] = PoolingLayer(16, 28, 2)
self.layers['LR'] = LocalRegionLayer(16, 28, nreg=3, sreg=1)
self.batch_size = 4
self.cost = Cost(mac_op=1,
mem_hier=(200, 6, 2, 1),
noc_hop=50,
idl_unit=50)
self.none_cstr = SchedulingConstraint()
self.cstr = SchedulingConstraint(topofm=1, topbat=self.batch_size)
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(4, 4),
type=NodeRegion.PROC),
dram_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(4, 1),
type=NodeRegion.DRAM),
src_data_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(4, 1),
type=NodeRegion.DRAM),
dst_data_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(4, 1),
type=NodeRegion.DRAM),
dim_array=PhyDim2(16, 16),
size_gbuf=65536,
size_regf=64,
array_bus_width=float('inf'),
dram_bandwidth=float('inf'),
no_time_mux=False)
self.options = Option(partition_hybrid=True,
partition_batch=True,
partition_ifmaps=True,
ntops=10)
self.ifmap_layouts = {}
part = PartitionScheme(order=(pe.INPP, pe.BATP, pe.OUTP, pe.OFMP),
pdims=((1, 2), (2, 1), (1, 2), (2, 1)))
for wlkey in self.layers:
input_layer = self.layers[wlkey].input_layer()
self.ifmap_layouts[wlkey] = DataLayout(
frngs=(FmapRange((0, 0, 0, 0),
FmapPosition(b=self.batch_size,
n=input_layer.nofm,
h=input_layer.hofm,
w=input_layer.wofm)), ),
regions=(self.resource.src_data_region, ),
parts=(part.projection(self.resource.src_data_region,
appl2frng=True), ))
self.sched_seq = (2, 0, 1)
def test_invalid_time_ovhd(self):
''' Invalid layer_pipeline_time_ovhd. '''
with self.assertRaisesRegexp(KeyError,
'Option: .*layer_pipeline_time_ovhd.*'):
_ = Option(layer_pipeline_time_ovhd=None)
with self.assertRaisesRegexp(ValueError,
'Option: .*layer_pipeline_time_ovhd.*'):
_ = Option(layer_pipeline_time_ovhd=-1)
def test_invalid_max_degree(self):
''' Invalid layer_pipeline_max_degree. '''
with self.assertRaisesRegexp(KeyError,
'Option: .*layer_pipeline_max_degree.*'):
_ = Option(layer_pipeline_max_degree=None)
with self.assertRaisesRegexp(ValueError,
'Option: .*layer_pipeline_max_degree.*'):
_ = Option(layer_pipeline_max_degree=-1)
def test_opt_goal(self):
''' Optimization goal. '''
network = self.alex_net
batch_size = 8
resource = self.resource._replace(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(8, 8),
type=NodeRegion.PROC)
)
nnd = NNDataflow(network, batch_size, resource, self.cost,
self.map_strategy)
options_e = Option(sw_gbuf_bypass=(True, True, True),
sw_solve_loopblocking=True,
partition_hybrid=True,
partition_batch=True,
opt_goal='e',
ntops=16)
tops_e, _ = nnd.schedule_search(options_e)
self.assertTrue(tops_e)
options_d = Option(sw_gbuf_bypass=(True, True, True),
sw_solve_loopblocking=True,
partition_hybrid=True,
partition_batch=True,
opt_goal='d',
ntops=16)
tops_d, _ = nnd.schedule_search(options_d)
self.assertTrue(tops_d)
options_ed = Option(sw_gbuf_bypass=(True, True, True),
sw_solve_loopblocking=True,
partition_hybrid=True,
partition_batch=True,
opt_goal='ed',
ntops=16)
tops_ed, _ = nnd.schedule_search(options_ed)
self.assertTrue(tops_ed)
self.assertLess(tops_e[0].total_cost, tops_d[0].total_cost)
self.assertLess(tops_e[0].total_cost, tops_ed[0].total_cost)
self.assertLess(tops_d[0].total_time, tops_e[0].total_time)
self.assertLess(tops_d[0].total_time, tops_ed[0].total_time)
# Sum of the smallest ED may not be the smallest; allow for error.
self.assertLess(tops_ed[0].total_cost * tops_ed[0].total_time,
tops_e[0].total_cost * tops_e[0].total_time * 1.05)
self.assertLess(tops_ed[0].total_cost * tops_ed[0].total_time,
tops_d[0].total_cost * tops_d[0].total_time * 1.05)
def test_gen_segment(self):
''' gen_segment(). '''
for net_name in self.net:
net = self.net[net_name]
ilp = self._make_ilp(net)
# No pipelining.
options = Option()
segs_n_lst = list(ilp.gen_segment(options))
segs_n = set(segs_n_lst)
self.assertEqual(len(segs_n_lst), len(segs_n))
for seg in segs_n:
self.assertEqual(len(seg), 1)
self.assertEqual(len(seg[0]), 1)
self.assertIn(seg[0][0], net)
# Spatial pipelining.
options = Option(partition_interlayer=True)
segs_sp_lst = list(ilp.gen_segment(options))
segs_sp = set(segs_sp_lst)
self.assertEqual(len(segs_sp_lst), len(segs_sp))
for seg in segs_sp:
for ltpl in seg:
self.assertLessEqual(sum(1 for l in ltpl
if isinstance(l, ConvLayer)),
1)
self.assertTrue(segs_sp.issuperset(segs_n))
# Temporal pipelining.
options = Option(hw_gbuf_save_writeback=True)
segs_tp_lst = list(ilp.gen_segment(options))
segs_tp = set(segs_tp_lst)
self.assertEqual(len(segs_tp_lst), len(segs_tp))
for seg in segs_tp:
self.assertEqual(len(seg), 1)
self.assertTrue(segs_tp.issuperset(segs_n))
# Spatial and temporal pipelining.
options = Option(partition_interlayer=True,
hw_gbuf_save_writeback=True)
segs_stp_lst = list(ilp.gen_segment(options))
segs_stp = set(segs_stp_lst)
self.assertEqual(len(segs_stp_lst), len(segs_stp))
self.assertSetEqual(segs_stp, segs_tp | segs_sp)
# Only single-layer and single-vertex segments have the same
# spatial and temporal pipelining.
segs_intersect = segs_tp & segs_sp
segs_single = segs_n
segs_single |= set(PipelineSegment((v,), ilp.network,
ilp.batch_size, ilp.resource)
for v in ilp.dag_vertex_list)
self.assertTrue(segs_intersect.issubset(segs_single))
def test_pernode_sched_cache_key(self):
''' Per-node scheduling cache key must be hash-able. '''
layer = self.layers['BASE']
ifmap_layout = self.ifmap_layouts['BASE']
schd = Scheduling(layer, self.batch_size, self.cost,
MapStrategyEyeriss)
condition = SchedulingCondition(resource=self.resource,
ifmap_layout=ifmap_layout)
_ = schd.schedule_search(condition, self.options)
h, m = schd.cache_stats()
self.assertEqual(h, 0)
# Make another instance.
rsrc = Resource(**self.resource._asdict())
opts = Option(**self.options._asdict())
self.assertNotEqual(id(rsrc), id(self.resource))
self.assertNotEqual(id(opts), id(self.options))
part = PartitionScheme(order=(pe.BATP, pe.INPP, pe.OUTP, pe.OFMP),
pdims=((2, 2), (2, 2), (1, 1), (1, 1)))
_ = schd.schedule_search_per_node(part, rsrc, opts)
h2, m2 = schd.cache_stats()
self.assertEqual(h2, h + 1)
self.assertEqual(m2, m)
def setUp(self):
self.alex_net = import_network('alex_net')
self.vgg_net = import_network('vgg_net')
self.map_strategy = MapStrategyEyeriss
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC),
data_regions=(NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DATA), ),
dim_array=PhyDim2(16, 16),
size_gbuf=128 * 1024 // 2, # 128 kB
size_regf=512 // 2, # 512 B
)
self.cost = Cost(mac_op=1,
mem_hier=(200, 6, 2, 1),
noc_hop=0,
unit_static=0)
self.options = Option()
def test_valid_args(self):
''' Valid arguments. '''
options = Option((False, True, False), True)
self.assertEqual(options.sw_gbuf_bypass, (False, True, False),
'sw_gbuf_bypass')
self.assertEqual(options.sw_solve_loopblocking, True,
'sw_solve_loopblocking')
def test_verbose(self):
''' Verbose mode. '''
network = self.alex_net
batch_size = 16
options = Option(sw_gbuf_bypass=(True, True, True),
sw_solve_loopblocking=True,
verbose=True)
nnd = NNDataflow(network, batch_size, self.resource, self.cost,
self.map_strategy)
old_stdout = sys.stdout
old_stderr = sys.stderr
sys.stdout = stdout = StringIO()
sys.stderr = stderr = StringIO()
tops, _ = nnd.schedule_search(options)
sys.stdout = old_stdout
sys.stderr = old_stderr
stdout_value = stdout.getvalue()
stderr_value = stderr.getvalue()
stdout.close()
stderr.close()
self.assertTrue(tops)
self.assertFalse(stdout_value)
for layer in network:
self.assertIn(layer, stderr_value)
def test_valid_kwargs(self):
''' Valid keyword arguments. '''
options = Option(sw_gbuf_bypass=(False, False, False),
sw_solve_loopblocking=False,
hw_access_forwarding=False,
hw_gbuf_sharing=False,
partition_hybrid=True,
partition_batch=False,
partition_ifmaps=False,
partition_interlayer=False,
opt_goal='ed',
ntops=10,
nprocesses=16,
verbose=False
)
self.assertEqual(options.sw_gbuf_bypass, (False, False, False),
'sw_gbuf_bypass')
self.assertEqual(options.sw_solve_loopblocking, False,
'sw_solve_loopblocking')
self.assertEqual(options.hw_access_forwarding, False,
'hw_access_forwarding')
self.assertEqual(options.hw_gbuf_sharing, False,
'hw_gbuf_sharing')
self.assertEqual(options.partition_hybrid, True,
'partition_hybrid')
self.assertEqual(options.partition_batch, False,
'partition_batch')
self.assertEqual(options.partition_ifmaps, False,
'partition_ifmaps')
self.assertEqual(options.partition_interlayer, False,
'partition_interlayer')
self.assertEqual(options.opt_goal, 'ed', 'opt_goal')
self.assertEqual(options.ntops, 10, 'ntops')
self.assertEqual(options.nprocesses, 16, 'nprocesses')
self.assertEqual(options.verbose, False, 'verbose')
def test_gen_segment_lstm(self):
''' gen_segment() with LSTM cell. '''
net = self.net['lstm_phoneme']
ilp = self._make_ilp(net)
options = Option(partition_interlayer=True)
# Find a cell.
cname = None
for l in net:
if l[-6:] == '_igate':
cname = l[:-6]
self.assertIsNotNone(cname)
# One LSTM cell fits.
segment = PipelineSegment(
((cname + '_cand',),
(cname + '_igate', cname + '_cout_i'),
(cname + '_fgate', cname + '_cout_f', cname + '_cout'),
(cname + '_ogate', cname + '_hout')),
ilp.network, ilp.batch_size, ilp.resource)
self.assertTrue(segment.valid)
segs = set(seg.seg for seg in ilp.gen_segment(options))
self.assertIn(segment.seg, segs)
def setUp(self):
self.layers = {}
self.layers['BASE'] = ConvLayer(64, 64, 28, 3)
self.layers['FC'] = FCLayer(4096, 1000, 6)
self.layers['POOL'] = PoolingLayer(32, 7, 3, strd=2)
self.layers['LR'] = LocalRegionLayer(32, 7, nreg=5, sreg=1)
# With irregular nifm/nofm.
self.layers['IRR'] = ConvLayer(255, 383, 13, 3)
# With small numbers of fmaps.
self.layers['SM'] = ConvLayer(5, 3, 13, 3)
# Super small networks. No partitioning schemes.
self.layers['SSM1'] = ConvLayer(1, 1, 2, 3)
self.layers['SSM2'] = FCLayer(2, 2)
self.layers['SSM3'] = PoolingLayer(1, 2, 2)
self.batch_size = 8
self.dim_nodes = {}
self.dim_nodes['BASE'] = PhyDim2(4, 4)
self.dim_nodes['LG'] = PhyDim2(10, 10)
self.dim_nodes['PRIME'] = PhyDim2(3, 3)
self.options = {}
# Irrelevant options.
optdict = {'ntops': 10000}
self.options['BASE'] = Option(partition_hybrid=True,
partition_batch=True,
partition_ifmaps=True,
**optdict)
self.options['NOBATP'] = Option(partition_hybrid=True,
partition_batch=False,
partition_ifmaps=True,
**optdict)
self.options['NOINPP'] = Option(partition_hybrid=True,
partition_batch=True,
partition_ifmaps=False,
**optdict)
self.options['NOHYB'] = Option(partition_hybrid=False,
partition_batch=True,
partition_ifmaps=False,
**optdict)
def test_default_args(self):
''' Default arguments. '''
options = Option()
self.assertTupleEqual(options.sw_gbuf_bypass, (False, False, False))
self.assertEqual(options.sw_solve_loopblocking, False)
self.assertEqual(options.partition_hybrid, False)
self.assertEqual(options.partition_batch, False)
self.assertEqual(options.partition_ifmaps, False)
self.assertEqual(options.ntops, 1)
self.assertEqual(options.nprocesses, 1)
self.assertEqual(options.verbose, False)
def setUp(self):
self.alex_net = import_network('alex_net')
self.vgg_net = import_network('vgg_net')
net = Network('simple')
net.set_input_layer(InputLayer(4, 2))
net.add('1', ConvLayer(4, 4, 2, 1))
net.add('2', ConvLayer(4, 4, 2, 1))
# Two more layers to avoid single-segment case.
net.add('a1', ConvLayer(4, 1, 1, 1, strd=2))
net.add('a2', ConvLayer(1, 1, 1, 1))
self.simple_net = net
net = Network('complex')
net.set_input_layer(InputLayer(8, 8))
net.add('1', ConvLayer(8, 8, 8, 1))
net.add('2a', ConvLayer(8, 8, 8, 1), prevs=('1', ))
net.add('3a', ConvLayer(8, 8, 8, 1))
net.add('2b', ConvLayer(8, 8, 8, 1), prevs=('1', ))
net.add('3b', ConvLayer(8, 8, 8, 1))
net.add('4', ConvLayer(16, 8, 8, 1), prevs=('3a', '3b'))
self.complex_net = net
self.map_strategy = MapStrategyEyeriss
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC),
dram_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DRAM),
src_data_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DRAM),
dst_data_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DRAM),
dim_array=PhyDim2(16, 16),
size_gbuf=128 * 1024 // 2, # 128 kB
size_regf=512 // 2, # 512 B
array_bus_width=float('inf'),
dram_bandwidth=float('inf'),
no_time_mux=False,
)
self.cost = Cost(mac_op=1,
mem_hier=(200, 6, 2, 1),
noc_hop=0,
idl_unit=0)
self.options = Option()
def test_pipelining(self):
''' Pipelining. '''
network = self.alex_net
batch_size = 1
options = Option(hw_gbuf_save_writeback=True,
partition_interlayer=True)
nnd = NNDataflow(network, batch_size, self.resource, self.cost,
self.map_strategy)
tops, _ = nnd.schedule_search(options)
self.assertTrue(tops)
def __init__(self, mlp_network):
self.net = mlp_network #MLP_network(18,32,64,32,2)
self.map_strategy = MapStrategyEyeriss
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC),
data_regions=(NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DATA), ),
dim_array=PhyDim2(16, 16),
size_gbuf=128 * 1024 // 2, # 128 kB
size_regf=512 // 2, # 512 B
)
self.cost = Cost(mac_op=1,
mem_hier=(200, 6, 2, 1),
noc_hop=0,
unit_static=0)
self.options = Option()
class TestMLP_network():
def __init__(self, mlp_network):
self.net = mlp_network #MLP_network(18,32,64,32,2)
self.map_strategy = MapStrategyEyeriss
self.resource = Resource(
proc_region=NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.PROC),
data_regions=(NodeRegion(origin=PhyDim2(0, 0),
dim=PhyDim2(1, 1),
type=NodeRegion.DATA), ),
dim_array=PhyDim2(16, 16),
size_gbuf=128 * 1024 // 2, # 128 kB
size_regf=512 // 2, # 512 B
)
self.cost = Cost(mac_op=1,
mem_hier=(200, 6, 2, 1),
noc_hop=0,
unit_static=0)
self.options = Option()
def test_eyeriss_isca16(self):
network = self.net
batch_size = 16
nnd = NNDataflow(network, batch_size, self.resource, self.cost,
self.map_strategy)
tops, cache_stats = nnd.schedule_search(self.options)
if not tops:
sys.stderr.write("No valid dataflow found!")
return None
dfsch = tops[0]
## Write results.
res_map = OrderedDict()
res_map['net'] = "MLP_L"
res_map['batch'] = batch_size
res_map['resource'] = self.resource._asdict()
res_map['cost'] = self.cost._asdict()
res_map['options'] = self.options._asdict()
res_map['cache_stats'] = cache_stats
stats = stats_dict(dfsch, self.cost)
for key, val in stats.items():
res_map[key] = val
return res_map
def test_gen_segment_max_degree(self):
''' gen_segment() maximum degree. '''
net = self.net['vgg_net']
ilp = self._make_ilp(net)
options = Option(partition_interlayer=True,
hw_gbuf_save_writeback=True,
layer_pipeline_max_degree=4)
for segment in ilp.gen_segment(options):
self.assertLessEqual(sum(1 if isinstance(net[l], ConvLayer) else 0
for ltpl in segment for l in ltpl),
4)
def _gen_all_partition(self, layerkey='PAR'):
'''
Generate PartitionScheme.
'''
options = Option(partition_hybrid=True,
partition_batch=True,
partition_ifmaps=True,
ntops=2**30)
for part in partition.gen_partition(
self.layer[layerkey], self.batch_size,
self.resource['PAR'].proc_region.dim, options):
yield part
def setUp(self):
super(TestLoopBlockingSolver, self).setUp()
# Bypass solver for each reside data category.
self.optkeys_bypsol = ['BYPSOL_{}'.format(dce) for dce in range(de.NUM)]
for reside_dce in range(de.NUM):
opt_dict = self.options['BYPSOL']._asdict()
byp = [True] * de.NUM
byp[reside_dce] = False
opt_dict['sw_gbuf_bypass'] = tuple(byp)
self.options[self.optkeys_bypsol[reside_dce]] = Option(**opt_dict)
def test_fast_forward_found(self):
''' Enter fast forward due to early found. '''
network = self.simple_net
batch_size = 1
# No time overhead limit.
options = Option(hw_gbuf_save_writeback=True,
partition_interlayer=True,
layer_pipeline_time_ovhd=float('inf'))
nnd = NNDataflow(network, batch_size, self.resource, self.cost,
self.map_strategy)
tops, _ = nnd.schedule_search(options)
self.assertTrue(tops)
def test_gen_segment_vseg(self):
''' gen_segment() vertex segment. '''
for net_name in self.net:
if not net_name.startswith('net'):
continue
net = self.net[net_name]
ilp = self._make_ilp(net)
options = Option(partition_interlayer=True)
seg_set = set(ilp.gen_segment(options))
self.assertTrue(seg_set)
seg_v_set = set(self._gen_all_segment(net))
self.assertTrue(seg_set.issubset(seg_v_set))
def test_gen_segment_one_nexts(self):
''' gen_segment() with missing one next vertex. '''
# pylint: disable=protected-access
net = self.net['net4']
ilp = self._make_ilp(net)
vseg_set = set(ilp._gen_vseg())
self.assertIn((7, 8), vseg_set)
self.assertNotIn((4, 5, 6), vseg_set)
options = Option(partition_interlayer=True)
seg_set = set(ilp.gen_segment(options))
self.assertIn(self._make_segment((7, 8), ilp.network), seg_set)
self.assertNotIn(self._make_segment((4, 5, 6), ilp.network), seg_set)
def test_gen_segment_multi_prevs(self):
''' gen_segment() with multiple previous vertices. '''
# pylint: disable=protected-access
net = self.net['net4']
ilp = self._make_ilp(net)
vseg_set = set(ilp._gen_vseg())
self.assertIn((9, 10), vseg_set)
self.assertIn((13, 14), vseg_set)
options = Option(partition_interlayer=True)
seg_set = set(ilp.gen_segment(options))
# 10 only has neighbor source 9; 10p only has local source 10 and
# memory source 8. Valid.
self.assertIn(self._make_segment((9, 10), ilp.network), seg_set)
# 14 has both neighbor source 13, and memory source 12, etc.. Invalid.
self.assertNotIn(self._make_segment((13, 14), ilp.network), seg_set)
def test_ext_layer(self):
''' With external layers. '''
network = self.alex_net
network.add_ext('e0', InputLayer(4, 1))
network.add('l1', FCLayer(1000, 4))
network.add('l2', FCLayer(8, 4), prevs=('e0', 'l1'))
batch_size = 16
options = Option(sw_gbuf_bypass=(True, True, True),
sw_solve_loopblocking=True)
nnd = NNDataflow(network, batch_size, self.resource, self.cost,
self.map_strategy)
tops, _ = nnd.schedule_search(options)
self.assertTrue(tops)
def test_gen_segment_resnet(self):
''' gen_segment() with ResNet. '''
net = self.net['resnet152']
ilp = self._make_ilp(net)
options = Option(partition_interlayer=True)
# One residual module fits.
segment = PipelineSegment(
(('conv3_2_a',), ('conv3_2_b',), ('conv3_2_c', 'conv3_2_res')),
ilp.network, ilp.batch_size, ilp.resource)
self.assertTupleEqual(net.prevs('conv3_2_res'),
('conv3_1_res', 'conv3_2_c'))
self.assertTrue(segment.valid)
segs = set(seg.seg for seg in ilp.gen_segment(options))
self.assertIn(segment.seg, segs)
def test_fmap_fwd(self):
'''
Fmap forward with shared mem sources or both on/off-chip destinations.
'''
network = self.complex_net
batch_size = 16
# Multiple nodes for spatial pipelining.
resource = self.resource._replace(proc_region=NodeRegion(
origin=PhyDim2(0, 0), dim=PhyDim2(8, 8), type=NodeRegion.PROC), )
# No time overhead limit.
options = Option(hw_gbuf_save_writeback=True,
partition_interlayer=True,
layer_pipeline_time_ovhd=float('inf'))
nnd = NNDataflow(network, batch_size, resource, self.cost,
self.map_strategy)
tops, _ = nnd.schedule_search(options)
self.assertTrue(tops)
def test_valid_kwargs(self):
''' Valid keyword arguments. '''
options = Option(sw_gbuf_bypass=(False, False, False),
sw_solve_loopblocking=False,
partition_hybrid=True,
partition_batch=False,
partition_ifmaps=False,
ntops=10,
nprocesses=16,
verbose=False)
self.assertEqual(options.sw_gbuf_bypass, (False, False, False),
'sw_gbuf_bypass')
self.assertEqual(options.sw_solve_loopblocking, False,
'sw_solve_loopblocking')
self.assertEqual(options.partition_hybrid, True, 'partition_hybrid')
self.assertEqual(options.partition_batch, False, 'partition_batch')
self.assertEqual(options.partition_ifmaps, False, 'partition_ifmaps')
self.assertEqual(options.ntops, 10, 'ntops')
self.assertEqual(options.nprocesses, 16, 'nprocesses')
self.assertEqual(options.verbose, False, 'verbose')
